wxruby3 0.9.0.pre.beta.8

data/ext/wxruby3/swig/wx.i

@@ -0,0 +1,282 @@
+// Copyright 2004-2007, wxRuby development team
+// released under the MIT-like wxRuby2 license
+
+%module(directors="1") wxruby3
+
+%include "common.i"
+
+%{
+#include <wx/gdicmn.h>
+#include <wx/image.h>
+#include <wx/xrc/xmlres.h>
+
+#include <wx/filesys.h>
+#include <wx/fs_zip.h>
+%}
+
+// Some common functions
+%{
+extern VALUE mWxCore;
+WXRUBY_EXPORT VALUE wxRuby_Core()
+{
+  return mWxCore;
+}
+
+// Mapping of known wxRuby classes to SWIG type information
+WX_DECLARE_HASH_MAP(VALUE,
+					swig_type_info*,
+					wxIntegerHash,
+					wxIntegerEqual,
+					RbClassToSwigTypeHash);
+RbClassToSwigTypeHash Global_Type_Map;
+
+// Record swig_type_info for a wxRuby class; called in class
+// initialisation
+WXRUBY_EXPORT void wxRuby_SetSwigTypeForClass(VALUE cls, swig_type_info* ty) {
+  Global_Type_Map[cls] = ty;
+}
+
+// Retrieve swig_type_info for a ruby class - needed by functions which
+// wrap objects whose type is not known in advance - eg
+// Window#find_window_by_index (see Window.i)
+WXRUBY_EXPORT swig_type_info* wxRuby_GetSwigTypeForClass(VALUE cls) {
+  return Global_Type_Map[cls];
+}
+
+// Overriding standard SWIG tracking - SWIG's implementation is not
+// compatible with ruby 1.8.7 / 1.9.x as it can allocate BigNum objects
+// during GC , which is an error. So instead we provide a C++ ptr->Ruby
+// object map using Wx's hashmap class.
+WX_DECLARE_VOIDPTR_HASH_MAP(VALUE,
+                            PtrToRbObjHash);
+PtrToRbObjHash Global_Ptr_Map;
+
+// Add a tracking from ptr -> object
+WXRUBY_EXPORT void wxRuby_AddTracking(void* ptr, VALUE object) {
+#ifdef __WXRB_DEBUG__
+  if (wxRuby_TraceLevel()>1)
+  {
+    std::wcout << "> wxRuby_AddTracking" << std::flush;
+    VALUE clsname = rb_mod_name(CLASS_OF(object));
+    std::wcout << "("
+               << ptr << ":{"
+               << (clsname != Qnil ? StringValueCStr(clsname) : "<noname>")
+               << "})" << std::endl;
+  }
+#endif
+  Global_Ptr_Map[ptr] = object;
+}
+
+// Return the ruby object for ptr
+WXRUBY_EXPORT VALUE wxRuby_FindTracking(void* ptr) {
+  if ( Global_Ptr_Map.count(ptr) == 0 )
+    return Qnil;
+  else
+    return Global_Ptr_Map[ptr];
+}
+
+// Remove the tracking for ptr
+WXRUBY_EXPORT void wxRuby_RemoveTracking(void* ptr) {
+#ifdef __WXRB_DEBUG__
+  if (wxRuby_TraceLevel()>1)
+    std::wcout << "< wxRuby_RemoveTracking(" << ptr << ")" << std::endl;
+#endif
+  Global_Ptr_Map.erase(ptr);
+}
+
+// Iterate over all the trackings, calling the passed-in method on each
+WXRUBY_EXPORT void wxRuby_IterateTracking( void(*meth)(void* ptr, VALUE obj) ) {
+  PtrToRbObjHash::iterator it;
+  for( it = Global_Ptr_Map.begin(); it != Global_Ptr_Map.end(); ++it )
+    {
+      void* ptr = it->first;
+      VALUE obj = it->second;
+      (*meth)(ptr, obj);
+    }
+}
+
+
+// Returns a ruby object wrapped around a wxObject. This is used for
+// methods whose return type is a generic C++ class (eg wxWindow), but
+// whose return values are actually instances of specific C++ classes
+// (eg wxButton) and so must be wrapped in the right Ruby class
+// (Wx::Button). It must check if the ruby wrapper object already
+// exists, and if not, wrap it in the correct class, and ensure that
+// future calls return the same object. Most of this is handled by the
+// SWIG API - the main additional complexity is using Wx's RTTI system
+// to discover the specific C++ class, then find a ruby class, and the
+// SWIG type info struct with the appropriate mark & free funcs to wrap
+// it in.
+//
+// This is useful for methods which return arbitrary windows - for
+// example, Window::FindWindowById or the FindWindowByPoint global
+// function; and in circumstances, especially XRC-loading, where
+// complete Windows are created in C++ without ruby code.
+WXRUBY_EXPORT VALUE wxRuby_WrapWxObjectInRuby(wxObject *wx_obj)
+{
+  static WxRuby_ID window_id("Window");
+
+  // If no object was passed to be wrapped; this could be a normal state
+  // (eg if get_sizer was called on a Window with no sizer set), or
+  // could be an error, eg if calling get_window_by_id and no window
+  // matched the id, or an error arose from incorrect XML syntax
+  if ( ! wx_obj )
+    return Qnil;
+
+  // Get the wx class and the ruby class we are converting into
+  wxString class_name( wx_obj->GetClassInfo()->GetClassName() );
+  wxCharBuffer wx_classname = class_name.mb_str();
+  VALUE r_class_name = rb_intern(wx_classname.data () + 2);
+  VALUE r_class = Qnil;
+
+  if ( class_name.Len() > 2 )
+  {
+    // lookup the class in the main module and any package submodules loaded
+    if (rb_const_defined(mWxCore, r_class_name))
+      r_class = rb_const_get(mWxCore, r_class_name);
+    else
+    {
+      VALUE submod_ary = rb_ivar_get(mWxCore, rb_intern("@__pkgmods__"));
+      for (long n=0; n<RARRAY_LEN(submod_ary); ++n)
+      {
+        VALUE submod = rb_ary_entry(submod_ary, n);
+        if (rb_const_defined(submod, r_class_name))
+        {
+          r_class = rb_const_get(submod, r_class_name);
+          break;
+        }
+      }
+    }
+  }
+
+  // Handle classes (currently) unknown in wxRuby.
+  // (could cause problems because class-specific methods won't be accessible).
+  if ( r_class == Qnil )
+  {
+    // map unknown wxWindow derivatives as basic window
+    if (wxIsKindOf(wx_obj, wxWindow))
+    {
+      r_class = rb_const_get(mWxCore, window_id());
+      // issue warning if $VERBOSE is true
+      rb_warning("Cannot wrap exact window class as '%s' is not (yet) known in wxRuby; wrapping as base Window object.",
+                 (const char *)class_name.mb_str());
+    }
+    else
+    {
+      rb_warn("Error wrapping object; class '%s' is not (yet) supported in wxRuby",
+              (const char *)class_name.mb_str());
+      return Qnil;
+    }
+  }
+
+  // Otherwise, retrieve the swig type info for this class and wrap it
+  // in Ruby. wxRuby_GetSwigTypeForClass is defined in wx.i
+  swig_type_info* swig_type = wxRuby_GetSwigTypeForClass(r_class);
+  VALUE r_obj = SWIG_NewPointerObj(wx_obj, swig_type, 1);
+  return r_obj;
+}
+
+
+// The passage of wxEvents from the C++ to the ruby side has to be
+// controlled carefully because normal Wx events are created on the
+// stack, and hence the underlying object is often deleted while the
+// ruby object is still around. This (plus typemap in typemap.i) gets
+// round this by tracking Event objects created on the ruby side with eg
+// CommandEvent.new, but never tracking, marking or freeing those
+// generated on the C++ side.
+// Cached reference to EvtHandler evt_type_id -> ruby_event_class map
+static VALUE Evt_Type_Map = NULL;
+
+#ifdef __WXRB_DEBUG__
+WXRUBY_EXPORT VALUE wxRuby_WrapWxEventInRuby(void* rcvr, wxEvent *wx_event)
+#else
+WXRUBY_EXPORT VALUE wxRuby_WrapWxEventInRuby(wxEvent *wx_event)
+#endif
+{
+  // Get the mapping of event types to classes
+  if ( ! Evt_Type_Map )
+  {
+    Evt_Type_Map = wxRuby_GetEventTypeClassMap ();
+  }
+
+#if __WXRB_DEBUG__
+  if (wxRuby_TraceLevel()>1)
+    std::wcout << "* wxRuby_WrapWxEventInRuby(rcvr=" << rcvr << ", " << wx_event << ":{" << wx_event->GetEventType() << "@" << wx_event->GetEventObject() << "})" << std::endl;
+#endif
+
+  // Then, look up the event type in this hash (MUCH faster than calling
+  // EvtHandler.evt_class_for_type method)
+  VALUE rb_event_type_id =  INT2NUM( wx_event->GetEventType() );
+  VALUE rb_event_class = rb_hash_aref(Evt_Type_Map, rb_event_type_id);
+
+  // Check we have a valid class; warn and map to default Wx::Event if not
+  if ( NIL_P(rb_event_class) )
+  {
+    rb_event_class = wxRuby_GetDefaultEventClass ();
+    wxString class_name( wx_event->GetClassInfo()->GetClassName() );
+    rb_warning("Unmapped event type %i (%s)", wx_event->GetEventType(), (const char *)class_name.mb_str());
+  }
+
+  // Now, see if we have a tracked instance of this object already
+  // wrapped - this would be the case if it had been created on the Ruby
+  // side.
+  VALUE rb_event = SWIG_RubyInstanceFor((void *)wx_event);
+
+  // Something has been found, but sometimes stale objects are left in
+  // the tracking, especially for types that are created and destroyed
+  // quickly; therefore, we need to verify that the found Ruby object is
+  // really the right thing, and not some stale reference.
+  if ( rb_event != Qnil )
+  {
+    if ( rb_obj_is_kind_of(rb_event, rb_event_class )  )
+      return rb_event; // OK
+    else
+      SWIG_RubyRemoveTracking((void *)wx_event); // Remove stale ref
+  }
+
+  // No existing Ruby instance found, so a transitory event object; wrap
+  // without mark or free functions as Wx will deals with deletion
+  rb_event = Data_Wrap_Struct(rb_event_class, 0, 0, 0);
+  DATA_PTR(rb_event) = wx_event;
+  // do not forget to mark the instance with the mangled swig type name
+  swig_type_info*  type = wxRuby_GetSwigTypeForClass(rb_event_class);
+  rb_iv_set(rb_event, "@__swigtype__", rb_str_new2(type->name));
+
+#if __WXRB_DEBUG__
+  if (wxRuby_TraceLevel()>1)
+    std::wcout << "* wxRuby_WrapWxEventInRuby - wrapped transitory event " << wx_event << "{" << type->name << "}" << std::endl;
+#endif
+
+  return rb_event;
+}
+%}
+
+%inline %{
+#ifdef __WXRB_DEBUG__
+int wxrb_trace_level = 0;
+#else
+const int wxrb_trace_level = 0;
+#endif
+%}
+
+%{
+#ifdef __WXRB_DEBUG__
+WXRUBY_EXPORT int wxRuby_TraceLevel()
+{
+  return _wxrb_trace_level;
+}
+#endif
+%}
+
+%include "mark_free_impl.i"
+
+%init %{
+  // Set up all image formats
+  wxInitAllImageHandlers();
+
+  // Load handlers on the global resources object
+  wxXmlResource::Get()->InitAllHandlers();
+
+	// This is needed so HtmlHelp can load docs from a zip file
+	wxFileSystem::AddHandler(new wxArchiveFSHandler);
+%}

data/ext/wxruby3/swig/wx.rc

@@ -0,0 +1,19 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        swig/wxruby.rc
+// Purpose:     wxRuby3 MSW standard resource file
+// Author:      Martin Corino
+/////////////////////////////////////////////////////////////////////////////
+
+// note that the icon used by the Explorer (i.e. the programs icon) is the
+// first icon in the executable and the icons are sorted both by their order
+// and alphabetically (!), so put this icon first and give it a name
+// starting with "a"
+aaaaaaaaWxRuby3 ICON "wxruby3/wxruby.ico"
+
+// To get DPI change events, we need to opt in into per monitor DPI support.
+#ifndef wxUSE_DPI_AWARE_MANIFEST
+#define wxUSE_DPI_AWARE_MANIFEST 2
+#endif
+
+// this file contains the standard icons, cursors, ...
+#include "wx/msw/wx.rc"

data/lib/wx/accessors.rb

@@ -0,0 +1,63 @@
+# = WxSugar - Accessors
+#
+# The default WxRuby interface has lots and lots of methods like
+#
+#  * get_position()
+#  * set_size(a_size)
+#  * is_checked()
+#  * can_undo()
+#  * has_style(a_style)
+# 
+# and so on. Methods that retrieve set, or query attributes of an object
+# are more normally in Ruby called simply by the attribute name, or, in
+# other cases, with a predicate method:
+#
+#  * pos = my_widget.position
+#  * my_widget.size = a_size
+#  * my_widget.checked?
+#  * my_widget.can_undo?
+#  * my_widget.has_style?
+#
+# The wxRuby generation scripts capture most of these and automatically declare
+# alias definitions for those. But not all.
+# This extension captures the ones that are still missing an appropriate alias and
+# automagically creates an alias for every WxRuby instance method that
+# begins with +get_+, +set_+, +is_+, +can_+ and +has_+. Note that if you are calling a
+# 'setter' method on self, you must explicitly send the message to self:
+# 
+#  # set's self size to be 100px by 100px
+#  self.size = Wx::Size.new(100, 100)
+#  # only sets the value of a local variable 'size'
+#  size = Wx::Size.new
+
+module WxRubyStyleAccessors
+  # Ruby-style method named are implemented by method-missing; if an
+  # unknown method is called, see if it is a rubyish name for a real
+  # method. In principle it would be possible to set up real aliases for
+  # them at start-up, but in practice this is far too slow for all the
+  # classes that need to be started up.
+  def method_missing(sym, *args)
+    case sym.to_s
+    when /^(\w+)\=$/ 
+      meth = "set_#{$1}"
+    when /^((?:has|can)\w+)\?$/
+      meth = $1
+    when /^(\w+)\?$/
+      meth = "is_#{$1}"
+    else
+      meth = "get_#{sym}"
+    end
+    if respond_to?(meth)
+      send(meth, *args)
+    else
+      super
+    end
+  end
+
+  def self.included(mod)
+    mod.extend WxRubyStyleAccessors
+    mod.constants.collect { | c | mod.const_get(c) }.grep(Module).each do |mod|
+      mod.include WxRubyStyleAccessors if mod.name.start_with?('Wx::') # only setup Wx namespace
+    end
+  end
+end

data/lib/wx/aui/auimanager.rb

@@ -0,0 +1,17 @@
+
+class Wx::AUI::AuiManager
+  def get_all_panes
+    ::Enumerator.new { |y| each_pane { |p| y << p } }
+  end
+  alias :all_panes :get_all_panes
+
+  unless Wx::EvtHandler.event_type_for_name(:evt_aui_find_manager)
+    # missing from XML API refs
+    Wx::EvtHandler.register_event_type Wx::EvtHandler::EventType[
+      'evt_aui_find_manager', 0,
+      Wx::AUI::EVT_AUI_FIND_MANAGER,
+      Wx::AUI::AuiManagerEvent
+    ] if Wx::AUI.const_defined?(:EVT_AUI_FIND_MANAGER)
+  end
+
+end

data/lib/wx/aui/auinotebook.rb

@@ -0,0 +1,9 @@
+# Advanced User Interface Notebook - draggable panes etc
+class Wx::AUI::AuiNotebook
+  # Convenience method for iterating pages
+  def each_page
+    0.upto(get_page_count - 1) do | i |
+      yield get_page(i)
+    end
+  end
+end

data/lib/wx/aui/require.rb

@@ -0,0 +1,9 @@
+# Wx::AUI sub package for wxRuby3
+# Copyright (c) M.J.N. Corino, The Netherlands
+
+#require_relative './ext'
+require_relative './events/evt_list'
+require_relative './auimanager'
+require_relative './auinotebook'
+
+Wx::Dialog.setup_dialog_functors(Wx::AUI)

data/lib/wx/aui.rb

@@ -0,0 +1,14 @@
+# Wx::AUI sub package loader for wxRuby3
+# Copyright (c) M.J.N. Corino, The Netherlands
+
+
+require 'wx/core'
+
+require 'wxruby_aui'
+
+require_relative './aui/require'
+
+::Wx.include(WxRubyStyleAccessors)
+
+::Wx.include(Wx::AUI) if defined?(::WX_GLOBAL_CONSTANTS) && ::WX_GLOBAL_CONSTANTS
+::Wx::AUI.include((defined?(::WX_GLOBAL_CONSTANTS) && ::WX_GLOBAL_CONSTANTS) ? WxGlobalConstants : WxEnumConstants)

data/lib/wx/core/acceleratortable.rb

@@ -0,0 +1,28 @@
+class Wx::AcceleratorTable
+  # Allow new to be called as []
+  class << self
+    alias :[] :new
+  end
+
+  # Allow initialize to be called with a splat-like list of arguments,
+  # and allow entries to be specified in terser form [mod, key, id]
+  # rather than full AcceleratorEntry.new call.
+  wx_init = self.instance_method(:initialize)
+  define_method(:initialize) do | *args |
+    # Test for old-style arg passing in a single array
+    if args.length == 1 and args.first.kind_of?(Array) and
+       args.first.all? { | e | e.kind_of?(Wx::AcceleratorEntry) }
+      args = args[0]
+    end
+    # Convert to array of AccEntries, to pass in as single array
+    args = args.map do | entry |
+      case entry 
+      when Wx::AcceleratorEntry then entry
+      when Array then Wx::AcceleratorEntry.new(*entry)
+      else Kernel.raise ArgumentError,
+                        "#{entry.inspect} is not a valid AcceleratorTable entry"
+      end
+    end
+    wx_init.bind(self).call(args)
+  end
+end

data/lib/wx/core/animation.rb

@@ -0,0 +1,18 @@
+class Wx::Animation
+  # Redefine the initialize method so it raises an exception if a
+  # non-existent file is given to the constructor; otherwise, wx Widgets
+  # just carries on with an empty bitmap, which may cause faults later
+  wx_init = self.instance_method(:initialize)
+  define_method(:initialize) do | *args |
+    if args[0].kind_of? String
+      if not File.exist?( File.expand_path(args[0]) )
+        Kernel.raise( ArgumentError, 
+                      "Animation file does not exist: #{args[0]}" )
+      end
+      res = wx_init.bind(self).call()
+      res.load_file(args[0], args[1] || Wx::ANIMATION_TYPE_ANY)
+    else
+      wx_init.bind(self).call(*args)
+    end
+  end
+end

data/lib/wx/core/app.rb

@@ -0,0 +1,89 @@
+# Copyright 2004-2006 by Kevin Smith
+# released under the MIT-style wxruby2 license
+
+require_relative './ext'
+
+# Controller class which creates and manages all windows.
+class Wx::App
+
+  # convenience method to retrieve global Wx::App instance
+  def self.the_app
+    if Wx::const_defined?(:THE_APP) and Wx::THE_APP.is_running
+      Wx::THE_APP
+    else
+      nil
+    end
+  end
+
+  # Ruby init callback.
+  # Initializes delayed load constants and than calls the user defined 'on_init'
+  def on_ruby_init
+    Wx.load_delayed_constants
+    self.respond_to?(:on_init) ? self.on_init : false
+  end
+  private :on_ruby_init
+
+  # Make C-ext main_loop method private
+  private :main_loop
+
+  # App instance run method.
+  # Accepts optional 'on_init' block.
+  # The block will be ignored when the (derived) App class
+  # already has an 'on_init' method defined.
+  def run(&block)
+    if block_given?
+      if self.respond_to?(:on_init)
+        Wx.log_warning("'on_init' block ignored as #{self.class.name} already has an #on_init method defined")
+      else
+        self.singleton_class.class_eval do
+          define_method(:on_init, &block)
+        end
+      end
+    end
+    main_loop # run the main loop (which triggers the call to on_init)
+  end
+
+  # Convenience class method to create simple apps. Starts an
+  # application main_loop, setting up initial windows etc as specified
+  # in the passed block.
+  # block 
+  def self.run(&block)
+    if block_given?
+      app_klass = Class.new(self)
+      app_klass.class_eval do
+        define_method(:on_init, &block)
+      end
+    else
+      app_klass = self
+    end
+    app_klass.new.run
+  end
+
+
+  # This is a class method in Wx, but permit it to be an instance method
+  # in wxRuby
+  def is_main_loop_running
+    Wx::App.is_main_loop_running
+  end
+
+  # This method handles failed assertions from within the WxWidgets C++
+  # code. These messages are only generated by a DEBUG build of
+  # WxRuby. Such messages usually indicate that the API is being used
+  # incorrectly; the file/line reference points to the place in the
+  # WxWidgets source code where the assertion was made.
+  define_method(:on_assert_failure) do | file, line, func, condition, message |
+    warn "Wx WARNING: #{message} (#{func}@#{file}:#{line})"
+  end
+
+  # For use in development only, of no practical use in production code.
+  # This method causes Ruby's garbage collection to run (roughly) at
+  # interval +interval+ (seconds) - the default is 1, i.e. every
+  # second. This should help ferret out bugs in memory management more
+  # quickly.
+  def gc_stress(interval = 1)
+    t = Wx::Timer.new(self, 9999)
+    evt_timer(9999) { Thread.pass }
+    Thread.new { loop { sleep interval; GC.start } }
+    t.start(100)
+  end
+end

data/lib/wx/core/artprovider.rb

@@ -0,0 +1,31 @@
+# Class which can supply icons and bitmaps
+class Wx::ArtProvider
+  # Keep a note of supplied ArtProviders to prevent them being GC'd
+  @__art_provs = []
+
+  class << self 
+    wx_push_back = instance_method(:push_back)
+    define_method(:push_back) do | art_prov |
+      wx_push_back.bind(self).call(art_prov)
+      @__art_provs.unshift(art_prov)
+    end
+
+    wx_pop = instance_method(:pop)
+    define_method(:pop) do
+      wx_pop.bind(self).call
+      @__art_provs.pop
+    end
+
+    wx_push = instance_method(:push)
+    define_method(:push) do | art_prov |
+      wx_push.bind(self).call(art_prov)
+      @__art_provs.push(art_prov)
+    end
+
+    wx_delete = instance_method(:delete)
+    define_method(:delete) do | art_prov |
+      wx_push.bind(self).call(art_prov)
+      @__art_provs.delete(art_prov)
+    end
+  end
+end

data/lib/wx/core/bitmap.rb

@@ -0,0 +1,59 @@
+# A platform-dependent image that can be drawn on the screen
+class Wx::Bitmap
+  # Allow wxRuby to guess the type of an image file from its extension.
+  BITMAP_TYPE_GUESS = { 
+    'bmp'  => Wx::BitmapType::BITMAP_TYPE_BMP,
+    'gif'  => Wx::BitmapType::BITMAP_TYPE_GIF,
+    'ico'  => Wx::BitmapType::BITMAP_TYPE_ICO,
+    'jpeg' => Wx::BitmapType::BITMAP_TYPE_JPEG,
+    'jpg'  => Wx::BitmapType::BITMAP_TYPE_JPEG,
+    'pbm'  => Wx::BitmapType::BITMAP_TYPE_PNM,
+    'pcx'  => Wx::BitmapType::BITMAP_TYPE_PCX,
+    'pgm'  => Wx::BitmapType::BITMAP_TYPE_PNM,
+    'png'  => Wx::BitmapType::BITMAP_TYPE_PNG,
+    'pnm'  => Wx::BitmapType::BITMAP_TYPE_PNM,
+    'ppm'  => Wx::BitmapType::BITMAP_TYPE_PNM,
+    'tga'  => Wx::BitmapType::BITMAP_TYPE_TGA,
+    'tif'  => Wx::BitmapType::BITMAP_TYPE_TIF,
+    'tiff' => Wx::BitmapType::BITMAP_TYPE_TIF,
+    'xbm'  => Wx::BitmapType::BITMAP_TYPE_XBM,
+    'xpm'  => Wx::BitmapType::BITMAP_TYPE_XPM
+  }
+
+  # Constructor copying data from an image
+  def self.from_image(img, depth = -1)
+    new(img, depth)
+  end
+
+  # Ruby methods that switch class are conventionally named to_foo
+  alias :to_image :convert_to_image
+
+  # Redefine the initialize method so it raises an exception if a
+  # non-existent file is given to the constructor; otherwise, wx Widgets
+  # just carries on with an empty bitmap, which may cause faults
+  # later. Also, be helpful and try to guess the bitmap type from the
+  # filename if it's not specified
+  wx_init = self.instance_method(:initialize)
+  define_method(:initialize) do | *args |
+    # If creating from a file, check it exists
+    if args[0].kind_of? String
+      if not File.exist?( File.expand_path(args[0]) )
+        Kernel.raise(ArgumentError, "Bitmap file does not exist: #{args[0]}")
+      end
+      # If type not specified, try to guess it from the file extension
+      if not args[1] and file_ext = args[0][/\w+$/]
+        args[1] = BITMAP_TYPE_GUESS[file_ext.downcase]
+      end
+    end
+    wx_init.bind(self).call(*args)
+  end
+
+  # Accepts a block, which will be passed a device context which can be
+  # used to draw upon the Bitmap
+  def draw
+    dc = Wx::MemoryDC.new
+    dc.select_object(self)
+    yield dc
+    dc.select_object( Wx::NULL_BITMAP )
+  end
+end

data/lib/wx/core/busycursor.rb

@@ -0,0 +1,12 @@
+# Emulates the wxWidgets BusyCursor class, by providing a scope within
+# which a busy cursor will be shown
+class Wx::BusyCursor
+  # Only one class method, optionally accepting a cursor that should be
+  # shown, defaulting to an hour glass cursor.
+  def self.busy(cursor = Wx::HOURGLASS_CURSOR)
+    Wx::begin_busy_cursor(cursor)
+    yield
+  ensure
+    Wx::end_busy_cursor
+  end
+end

data/lib/wx/core/choice.rb

@@ -0,0 +1,4 @@
+class Wx::Choice
+  alias :get_item_data :get_client_data
+  alias :set_item_data :set_client_data
+end