wxruby3 0.9.0.pre.beta.14 → 0.9.0.pre.rc.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5e6a85a400700ba48119fc656cf79208b3f5f603eaafb01d30206de46876dbf1
-  data.tar.gz: ffe7e7cde7840f547efe45893162bfc54e2bd9402d7aaf975a98f298fbdbdf8e
+  metadata.gz: 9bc61b2275cfa2dd3f0616b3b899a0bdc8c006cb0f06d77b150cf1f596d3874e
+  data.tar.gz: 5c4ecc0394f8aeb5257f243adf488991add90a3f4f6fbe77e91d06e0f08abde6
 SHA512:
-  metadata.gz: 86dc10b04a49bd56825267b23117720fa5b2398cb01194cdd050fa9d8f6c81ba5a80426447a82fa747a725cdb1802bc0138ebd43322c7c162104a14c5a71ebb3
-  data.tar.gz: e9aa356d29c7d571f68a99dbd33041aed71d770951cca3d32a37b5eab634da938b9da931dad7fefafb67ad33401535357c27db647798e764abdd0def4133f09a
+  metadata.gz: e765d9941397f20fc0f770bbfc5e2e0a73ca00b76101c098d84a9802a5d3f924ea52f65ea8f960f3a1269f30aaa3fb5636aef61bf064784dc0716eb31ac27ab2
+  data.tar.gz: 994a3226ca8f8d61fc0bdff11fa1bce572614d40b6f351b49dea7f6b2ce0f2a4915114dbfccd20562c7a236280ce7575ef779cc358f628d5188613abee37d060

data/.yardopts

@@ -1,6 +1,7 @@
 --load rakelib/yard/yard-relative_markdown_links.rb
 --load rakelib/yard/yard-custom-templates.rb
 --charset UTF-8
+--markup markdown
 --readme README.md
 --title "wxRuby3 API Documentation"
 --output-dir rdoc

data/INSTALL.md

@@ -4,32 +4,45 @@
 
 # Installation of wxRuby3
 
+## Minimal requirements for installing wxRuby3
+
+The minimal requirements for installing any source based setup (gem, source package or Github clone) of wxRuby3 are:
+
+| Sofware                                       | Notes                                                                                                                                                                                                                           |
+|-----------------------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| Ruby                                          | A supported version of the Ruby interpreter needs to be installed.                                                                                                                                                              |
+| C++ compiler<br>(incl. dev tools like `make`) | On linux a recent version of the GNU C++ compiler (with c++-14 support) needs to be installed<br>On Windows the RubyInstaller MSYS2-Devkit needs to be installed<br>On MacOS XCode with commandline tools needs to be installed |
+| Git version control toolkit                   |                                                                                                                                                                                                                                 |
+| SWIG >= 3.0.12                                | On MacOS install [Homebrew](https://brew.sh/) and than `brew install swig`                                                                                                                                                      |
+| Doxygen (>= 1.9.1, <= 1.9.6)                  | Doxygen > 1.9.6 has changes that cause problems with the wxWidgets doxygen files.<br>On MacOS: `brew tap mcorino/wxruby3` and than `brew install doxygen@1.9.6` (default brew recipe installs 1.9.7)                            |
+
+The wxRuby3 build process requires `git` to clone a copy of the wxWidgets Github repository to extract the interface 
+specifications from.<br>
+The wxRuby3 build process needs doxygen to generated XML files containing wxWidgets interface specs which are used to 
+generate SWIG interface definitions from which SWIG to generates C++ source code for the wrapper interfaces from
+which the native extension is compiled.
+
 ## Installation of a wxRuby3 Gem
 
 The wxRuby3 project provides gems on [RubyGems](https://rubygems.org) which can be installed with the
 standard `gem install` command line this:
 
-```sh
+```shell
 gem install wxruby3
  ```
 
 On Linux systems this will install the source based gem which will automatically build the native wxruby3 extension
 for the platform on which wxRuby3 is being installed.
 On Windows systems a prebuilt binary gem is available for the latest stable release(s) of [RubyInstaller](https://rubyinstaller.org) 
-installed rubies that will be installed by default if installing for that platform. Alternatively the source gem can be
-installed on Windows by installing with explicit platform specification like this:
+installed rubies that will be installed by default if installing for that platform (including an embedded, latest 
+stable version, wxWidgets installation).<br>
+Alternatively the source gem can be installed on Windows by installing with explicit platform specification like this:
 
-```sh
+```shell
 gem install wxruby3 --platform=ruby
 ```
 
-When installing the source gem the following basic requirements apply:
-
-- Git version control toolkit
-- Ruby 2.5 or later (including development package)
-- GNU g++ 4.8 or later on Linux, RubyInstaller+DevKit on Windows
-- [SWIG](https://www.swig.org) 3.0.12 or later
-- [Doxygen](https://www.doxygen.nl/)
+When installing the source gem the minimal requirements listed above apply.
 
 Also a wxWidgets installation (version 3.2 or later) is required for which there are multiple options.
 
@@ -39,38 +52,54 @@ Also a wxWidgets installation (version 3.2 or later) is required for which there
    The wxRuby build procedure will determine the availability and version of wxWidgets by locating and calling
    the `wx-config` utility script. In case no (compatible) wxWidgets version is found installation ends with an error.<br>
    Please note that even with this method a copy of the wxWidgets project will be checked out from GitHUb as the wxRuby3
-   build procedure requires access to the wxWidgets interface specification sources (see [here](TODO) for more details). 
+   build procedure requires access to the wxWidgets interface specification sources which are not normally part of any of 
+   the standard distribution packages.
    
 
 2. User installed wxWidgets version<br>
    <br>
-   In case the being system installed on does not provide (a compatible) wxWidgets version or a specific (possibly updated)
+   In case the system being installed on does not provide (a compatible) wxWidgets version or a specific (possibly updated)
    wxWidgets version is required the source gem can be installed using a user installed version like this (where the 
    `WXWIN` path should provide the location where the wxWidgets binaries are installed under `<wxwin path>/bin`):<br>
 
-```sh
+```shell
    gem install wxruby3 -- WXWIN=/path/to/wx/install 
 ```
    
-3. Automatic installed wxWidgets version<br>
+3. Automatic installed, embedded, wxWidgets version<br>
    <br>
-   This is the easiest method when the being system installed on does not provide (a compatible) wxWidgets version (and 
+   This is the easiest method when the system being installed on does not provide (a compatible) wxWidgets version (and 
    no specific user defined version is required) and can be used by installing the source gem like this (which will
-   cause automatic checkout and building of the latest wxWidgets release (>= 3.2) from GitHub:
-
+   cause automatic checkout and building of the latest stable wxWidgets release (>= 3.2) from GitHub:
 
-```sh
+```shell
    gem install wxruby3 -- WITH_WXWIN=1
 ```
 
+In case of option **2** it is also possible to do the doxygen XML generation as part of the wxWidgets user installation
+and use that for the gem installation. In that case the user is required to generate the XML interface specs using the
+`regen` script found in the `docs/doxygen` folder of the wxWidgets installation after which the XML output folder can be 
+provided to the gem installation as follows:
+
+```shell
+   gem install wxruby3 -- WXWIN=/path/to/wx/install WXXML=/path/to/wx/doxygen/xml
+```
+
+Please also not that in case of option two the user is responsible to make sure the wxWidgets shared libraries can be
+found by the system's dynamic loader at runtime.
+
 > **NOTE:** Be patient when installing the source gem. Building wxRuby3 takes a while and when wxWidgets is included event more. 
 
+> **NOTE:** Be aware that for prerelease versions of the gem you should add the `--pre` argument to the `gem install` command. 
+
 ## Building from source
 
-Checkout the wxRuby3 sources from [GitHub](https://github.com/mcorino/wxRuby3).
+Checkout the wxRuby3 sources from [GitHub](https://github.com/mcorino/wxRuby3) or download and unpack a release package.
 
-Basic requirements are the same as for installing the source gem. Gem dependencies are listed in the Gemfile in the root
-of the wxRuby3 tree.
+Requirements are the same as for installing the source gem. Gem dependencies are listed in the Gemfile in the root
+of the wxRuby3 tree and should be installed by executing `bundle install`.<br>
+To be able to generate HTML documentation the optional `:documentation` group should be included.<br>
+To be able to run the Rake memory check task the option `:develop` group should be included.
 
 The wxRuby3 project provides a Rake based build system. Call `rake help` to get an overview of the available commands.
 As mentioned there the `rake configure` command is required as the very first command. Call `rake configure[--help]` to

data/README.md

@@ -1,9 +1,11 @@
 [![Linux wxGTK](https://github.com/mcorino/wxRuby3/actions/workflows/linux.yml/badge.svg)](https://github.com/mcorino/wxRuby3/actions/workflows/linux.yml)
 [![Windows wxMSW](https://github.com/mcorino/wxRuby3/actions/workflows/msw.yml/badge.svg)](https://github.com/mcorino/wxRuby3/actions/workflows/msw.yml)
+[![Mac wxOSX](https://github.com/mcorino/wxRuby3/actions/workflows/mac.yml/badge.svg)](https://github.com/mcorino/wxRuby3/actions/workflows/mac.yml)
+
 [![License](https://img.shields.io/badge/license-MIT-yellowgreen.svg)](LICENSE)
 [![Gem Version](https://badge.fury.io/rb/wxruby3.svg)](https://badge.fury.io/rb/wxruby3)
-
 [![Documentation](https://img.shields.io/badge/docs-pages-blue.svg)](https://mcorino.github.io/wxRuby3)
+[![Chat](https://img.shields.io/gitter/room/mcorino/wxruby)](https://gitter.im/mcorino/wxruby3)
 
 # README for wxRuby3
 
@@ -13,12 +15,52 @@ Reviving wxRuby
 
 ## Introduction
 
-wxRuby3 is a cross-platform GUI library for Ruby, based on the [wxWidgets](https://wxwidgets.org)
+wxRuby3 is a cross-platform GUI library for Ruby, based on the mature [wxWidgets](https://wxwidgets.org)
 GUI toolkit for C++. It uses native widgets wherever possible, providing
 the correct look, feel and behaviour to GUI applications on Windows, OS
 X and Linux/GTK. wxRuby aims to provide a comprehensive solution to
 developing professional-standard desktop applications in Ruby. 
 
+## Usage examples
+
+### Hello world
+
+wxRuby3 is very easy to use.
+
+```ruby
+require 'wx'
+
+Wx::App.run do
+  Wx::Frame.new(nil, title: 'Hello world!').show
+end
+```
+
+![Hello_World](assets/hello_world_combi.png "Hello World sample")
+
+### Hello Button
+
+Anyone who is familiar with wxWidgets should feel right at home since the API may be Ruby-fied, it is still easily 
+recognizable (but being Ruby-fied allowing for elegant and compact coding). And for those that do not have previous 
+experience, do not fear, wxRuby3 comes with detailed [documentation](https://mcorino.github.io/wxRuby3/file.00_starting.html) and lots of examples and tests.    
+
+```ruby
+require 'wx'
+
+class TheFrame < Wx::Frame
+  def initialize(title)
+    super(nil, title: title)
+    panel = Wx::Panel.new(self)
+    button = Wx::Button.new(panel, label: 'Click me')
+    button.evt_button(Wx::ID_ANY) { Wx.message_box('Hello. Thanks for clicking me!', 'Hello Button sample') }
+  end
+end
+
+Wx::App.run { TheFrame.new('Hello world!').show }
+```
+
+![Hello_Button_Clicked](assets/hello_button_clicked_combi.png "Hello Button sample clicked")
+
+
 ## wxRuby3 licence
 
 wxRuby3 is free and open-source. It is distributed under the liberal
@@ -54,14 +96,43 @@ of these products.
 
 Currently the following are fully supported:
 
-* Windows 10 (RubyInstaller MSYS2-DevKit) / Ruby >= 2.5 / wxWidgets >= 3.2
-* Linux (i686 + AMD-64) / Ruby >= 2.5 / wxWidgets >= 3.2
+| Platform                                                                   | Ruby version(s) | wxWidgets version(s) |
+|----------------------------------------------------------------------------|-----------------| --- |
+| Windows 10 (tested)<br>(most likely also Windows 11)                       | Ruby >= 2.5<br>(RubyInstaller MSYS2-DevKit) | wxWidgets >= 3.2 |
+| Linux (tested; any AMD-64 distribution)<br>(most likely also i686 and ARM) | Ruby >= 2.5 | wxWidgets >= 3.2 |
+| MacOS >= 10.10 using Cocoa (tested on AMD-64)                              | Ruby >= 2.5 | wxWidgets >= 3.2 | 
 
 Support for other platforms is not being actively developed at present,
 but patches are welcome. It is likely to be much simpler to get wxRuby
 working on similar modern systems (eg FreeBSD or Solaris with GTK) than
 on legacy systems (eg Windows 98, Mac OS 9).
 
+### How can I install wxRuby3?
+
+wxRuby3 is distributed as a Ruby gem on [RubyGems](https://rubygems.org).<br>
+Apart from a regular source-only version of the gem there is also a binary gem version for Windows 10 provided (for the 
+latest stable Ruby version at the time of publishing) which includes an embedded wxWidgets installation (also latest 
+stable version). 
+
+Installing the binary gem version on Windows requires no additional software to be installed except for a supported 
+version of the Ruby interpreter.<br>
+To install the source-only gem the following software is required:
+
+| Sofware                                       | Notes                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
+|-----------------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| Ruby                                          | A supported version of the Ruby interpreter needs to be installed.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
+| C++ compiler<br>(incl. dev tools like `make`) | On linux a recent version of the GNU C++ compiler (with c++-14 support) needs to be installed<br>On Windows the RubyInstaller MSYS2-Devkit needs to be installed<br>On MacOS XCode with commandline tools needs to be installed                                                                                                                                                                                                                                                                                                                                                                                                              |
+| Git version control toolkit                   |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
+| SWIG >= 3.0.12                                | On MacOS install [Homebrew](https://brew.sh/) and than `brew install swig`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| Doxygen (>= 1.9.1, <= 1.9.6)                  | Doxygen > 1.9.6 has changes that cause problems with the wxWidgets doxygen files.<br>On MacOS: `brew tap mcorino/wxruby3` and than `brew install doxygen@1.9.6` (default brew recipe installs 1.9.7)                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| wxWidgets >= 3.2 (*OPTIONAL*)                 | On Linux most distributions provide system installable (development) packages for wxWidgets providing a supported version. Alternatively you can fairly easily install your own preferred version manually (see the [wxWidgets](https://wxwidgets.org) project for details).<br>On Windows and MacOS the process is less straightforward (also here see the [wxWidgets](https://wxwidgets.org) project for details).<br>The wxRuby3 source-only gem can also be installed using a private local wxWidgets installation or an embedded installation (most likely preferred on Windows and MacOS). See [INSTALL](INSTALL.md) for more details. |    
+
+In case the prerequisites above are met the (source-only or binary) gem can be installed executing the following command:
+
+```shell
+gem install wxruby3
+```
+
 ### Where can I ask a question, or report a bug?
 
 Use GitHUb Issues.
@@ -109,7 +180,7 @@ which may be relevant.
 
 ### What wxWidgets features are supported by wxRuby3?
 
-wxRuby supports almost all of the wxWidgets 3.x GUI API, providing over
+wxRuby supports almost all of the wxWidgets 3.2+ GUI API, providing over
 600 classes in total. wxWidgets classes that provide general and/or non-GUI 
 programming support features, such as strings, networking, threading, database
 access and such are not and will never be ported, as it's assumed that 
@@ -137,5 +208,9 @@ maintainable solution.
 
 ### I am getting an error trying to install or compile wxRuby3
 
-Please double-check the [INSTALL](INSTALL.md) documents, and search issue archives. If 
+Please double-check the instructions above and in the [INSTALL](INSTALL.md) document and search issue archives. If 
 this doesn't help, please post your question using GitHub Issues.
+
+### Is there another, more declarative way, for writing wxRuby3 desktop GUI applications?
+
+Yes. [Glimmer DSL for WX](https://github.com/AndyObtiva/glimmer-dsl-wx) enables software engineers to build GUI using wxruby3 following the Ruby way with the least amount of code possible. That is by offering a minimalistic declarative high-level DSL that maps visually to the way software engineers think about the GUI hierarchy in addition to adopting Rails' strategy of Convention over Configuration via smart defaults and automation of wxruby3 low-level details. You can check out the [Glimmer DSL for WX README "Coming From wxruby3" section](https://github.com/AndyObtiva/glimmer-dsl-wx#coming-from-wxruby3) for more information on how to translate wxruby3 apps to [Glimmer DSL for WX](https://github.com/AndyObtiva/glimmer-dsl-wx) syntax.

data/ext/wxruby3/include/wxruby-runtime.h

@@ -57,6 +57,7 @@ WXRUBY_EXPORT bool GC_IsWindowDeleted(void *ptr);
 // Defined in wx.i; getting, setting and using swig_type <-> ruby class
 // mappings
 WXRUBY_EXPORT swig_type_info* wxRuby_GetSwigTypeForClass(VALUE cls);
+WXRUBY_EXPORT swig_type_info* wxRuby_GetSwigTypeForClassName(const char* clsname);
 WXRUBY_EXPORT void wxRuby_SetSwigTypeForClass(VALUE cls, swig_type_info* ty);
 
 // Common wrapping functions

data/ext/wxruby3/swig/memory_management.i

@@ -97,14 +97,11 @@ GC_NEVER(kls);
 %enddef
 
 // Strategy for objects whose pointer / id identity does not matter,
-// only their attributes: Size, Point and Rect. They are commonly
-// created as temporary objects on the stack in C++ and then passed into
+// only their attributes and/or methods like DC (and derivatives) Size, Point and Rect. They are commonly
+// created as temporary objects (mostly on the stack) in C++ and then passed into
 // director methods. Once the director method has run they should no
 // longer be referenced in ruby.
-%define GC_MANAGE_AS_FUNGIBLE_OBJECT(kls)
-%enddef
-
-%define GC_MANAGE_AS_TEMP(kls)
+%define GC_MANAGE_AS_UNTRACKED(kls)
 %enddef
 
 // Sizers attached to windows are automatically destroyed by wxWidgets,
@@ -133,10 +130,9 @@ GC_NEVER(kls);
 %enddef
 
 
-// All other classes - mainly helper classes (eg Sizer, GridCellxxx) and
-// informational classes eg Point, Size, Rect. These are tracked but
-// sometimes later disowned once passed into a widget, and thenceforth
-// managed by WxWidgets
+// All other classes - mainly helper classes (eg Sizer, GridCellxxx).
+// These are tracked but sometimes later disowned once passed into a
+// widget, and thenceforth managed by WxWidgets
 %define GC_MANAGE(kls)
 GC_MANAGE_AS_OBJECT(kls)
 %enddef

data/ext/wxruby3/swig/wx.i

@@ -32,17 +32,24 @@ 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) {
+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) {
+WXRUBY_EXPORT swig_type_info* wxRuby_GetSwigTypeForClass(VALUE cls)
+{
   return Global_Type_Map[cls];
 }
 
+WXRUBY_EXPORT swig_type_info* wxRuby_GetSwigTypeForClassName(const char* clsname)
+{
+  return wxRuby_GetSwigTypeForClass(rb_const_get(wxRuby_Core(), rb_intern(clsname)));
+}
+
 // 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
@@ -52,7 +59,8 @@ WX_DECLARE_VOIDPTR_HASH_MAP(VALUE,
 PtrToRbObjHash Global_Ptr_Map;
 
 // Add a tracking from ptr -> object
-WXRUBY_EXPORT void wxRuby_AddTracking(void* ptr, VALUE object) {
+WXRUBY_EXPORT void wxRuby_AddTracking(void* ptr, VALUE object)
+{
 #ifdef __WXRB_DEBUG__
   if (wxRuby_TraceLevel()>1)
   {
@@ -68,7 +76,8 @@ WXRUBY_EXPORT void wxRuby_AddTracking(void* ptr, VALUE object) {
 }
 
 // Return the ruby object for ptr
-WXRUBY_EXPORT VALUE wxRuby_FindTracking(void* ptr) {
+WXRUBY_EXPORT VALUE wxRuby_FindTracking(void* ptr)
+{
   if ( Global_Ptr_Map.count(ptr) == 0 )
     return Qnil;
   else
@@ -76,7 +85,8 @@ WXRUBY_EXPORT VALUE wxRuby_FindTracking(void* ptr) {
 }
 
 // Remove the tracking for ptr
-WXRUBY_EXPORT void wxRuby_RemoveTracking(void* ptr) {
+WXRUBY_EXPORT void wxRuby_RemoveTracking(void* ptr)
+{
 #ifdef __WXRB_DEBUG__
   if (wxRuby_TraceLevel()>1)
     std::wcout << "< wxRuby_RemoveTracking(" << ptr << ")" << std::endl;
@@ -85,7 +95,8 @@ WXRUBY_EXPORT void wxRuby_RemoveTracking(void* ptr) {
 }
 
 // Iterate over all the trackings, calling the passed-in method on each
-WXRUBY_EXPORT void wxRuby_IterateTracking( void(*meth)(void* ptr, VALUE obj) ) {
+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 )
     {

data/lib/wx/core/art_locator.rb

@@ -54,7 +54,7 @@ module Wx
       private :search_paths
 
       def add_search_path(*paths)
-        paths.flatten.each { |p| paths << s.to_s unless paths.include?(s.to_s) }
+        paths.flatten.each { |p| search_paths << p.to_s unless search_paths.include?(p.to_s) }
       end
       alias :add_search_paths :add_search_path
 
@@ -74,7 +74,7 @@ module Wx
 
       def find_art(art_name, art_type: nil, art_path: nil, art_section: nil, bmp_type: nil)
         unless art_path
-          caller_path = caller_locations(1).first.absolute_path
+          caller_path = caller_locations(1).first.absolute_path || caller_locations(1).first.path
           art_path = File.dirname(caller_path)
           art_section ||= File.basename(caller_path, '.*')
         end

data/lib/wx/core/artprovider.rb

@@ -7,7 +7,7 @@ class Wx::ArtProvider
     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)
+      @__art_provs.push(art_prov)
     end
 
     wx_pop = instance_method(:pop)
@@ -19,7 +19,7 @@ class Wx::ArtProvider
     wx_push = instance_method(:push)
     define_method(:push) do | art_prov |
       wx_push.bind(self).call(art_prov)
-      @__art_provs.push(art_prov)
+      @__art_provs.unshift(art_prov)
     end
 
     wx_delete = instance_method(:delete)

data/lib/wx/core/bitmap.rb

@@ -86,15 +86,16 @@ module Wx
     # 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 )
+      return unless block_given?
+      Wx::MemoryDC.draw_on(self) do |dc|
+        dc.select_object(self)
+        yield dc
+      end
     end
   end
 
   def self.Bitmap(name, bmp_type = nil)
-    art_path = File.dirname(caller_path = caller_locations(1).first.absolute_path)
+    art_path = File.dirname(caller_path = caller_locations(1).first.absolute_path || caller_locations(1).first.path)
     art_owner = File.basename(caller_path, '.*')
     art_file = ArtLocator.find_art(name, art_type: :bitmap, art_path: art_path, art_section: art_owner, bmp_type: bmp_type)
     ::Kernel.raise ArgumentError, "Cannot locate art file for #{name}:Bitmap" unless art_file

data/lib/wx/core/bitmap_combobox.rb

@@ -0,0 +1,34 @@
+
+module Wx
+
+  class BitmapCombobox < Wx::ComboBox
+
+    # We need to cache client data in Ruby variables as we cannot access items
+    # during the GC mark phase as for some platforms (WXMSW at least) that would
+    # involve calling methods that would break in that phase.
+
+    wx_append = instance_method :append
+    define_method :append do |item, bitmap=Wx::NULL_BITMAP, data=nil|
+      itm_pos = if data
+                  wx_append.bind(self).call(item, bitmap, data)
+                else
+                  wx_append.bind(self).call(item, bitmap)
+                end
+      client_data_store.insert(itm_pos, data)
+      itm_pos
+    end
+
+    wx_insert = instance_method :insert
+    define_method :insert do |item, bitmap, pos, data=nil|
+      itm_pos = if data
+                  wx_insert.bind(self).call(item, bitmap, pos, data)
+                else
+                  wx_insert.bind(self).call(item, bitmap, pos)
+                end
+      client_data_store.insert(itm_pos, data)
+      itm_pos
+    end
+
+  end
+
+end

data/lib/wx/core/brush.rb

@@ -0,0 +1,6 @@
+
+module Wx
+
+  TheBrushList = Wx::Brush
+
+end

data/lib/wx/core/controlwithitems.rb

@@ -32,6 +32,7 @@ class Wx::ControlWithItems
 
   wx_append = instance_method :append
   define_method :append do |item, data=nil|
+    itm_pos = -1
     if data
       if ::Array === item
         if !(::Array === data)
@@ -39,21 +40,42 @@ class Wx::ControlWithItems
         elsif data.size != item.size
           ::Kernel.raise ::ArgumentError.new("item and data array must be equal size")
         end
-        offs = get_count
-        wx_append.bind(self).call(item)
-        item.size.times { |ix| set_client_data(offs+ix, data[ix]) }
+        if sorted?
+          item.each_with_index do |itm, ix|
+            itm_pos = wx_append.bind(self).call(itm, data[ix])
+            client_data_store.insert(itm_pos, data[ix])
+          end
+        else
+          offs = get_count
+          itm_pos = wx_append.bind(self).call(item)
+          item.size.times { |ix| set_client_data(offs+ix, data[ix]) }
+        end
       else
-        wx_append.bind(self).call(item, data)
-        client_data_store[get_count-1] = data
+        itm_pos = wx_append.bind(self).call(item, data)
+        client_data_store.insert(itm_pos, data)
       end
     else
-      wx_append.bind(self).call(item)
-      # no changes to data store
+      if ::Array === item
+        if sorted?
+          item.each_with_index do |itm, ix|
+            itm_pos = wx_append.bind(self).call(itm, data[ix])
+            client_data_store.insert(itm_pos, nil)
+          end
+        else
+          itm_pos = wx_append.bind(self).call(item)
+          client_data_store.concat(::Array.new(item.size))
+        end
+      else
+        itm_pos = wx_append.bind(self).call(item)
+        client_data_store.insert(itm_pos, nil)
+      end
     end
+    itm_pos
   end
 
   wx_insert = instance_method :insert
   define_method :insert do |item, pos, data=nil|
+    itm_pos = -1
     if data
       if ::Array === item
         if !(::Array === data)
@@ -61,21 +83,37 @@ class Wx::ControlWithItems
         elsif data.size != item.size
           ::Kernel.raise ::ArgumentError.new("item and data array must be equal size")
         end
-        wx_insert.bind(self).call(item, pos)
-        client_data_store.insert(pos, *::Array.new(item.size))
-        item.size.times { |ix| set_client_data(pos+ix, data[ix]) }
+        if sorted?
+          item.each_with_index do |itm, ix|
+            itm_pos = wx_insert.bind(self).call(itm, data[ix])
+            client_data_store.insert(itm_pos, data[ix])
+          end
+        else
+          itm_pos = wx_insert.bind(self).call(item, pos)
+          client_data_store.insert(pos, *::Array.new(item.size))
+          item.size.times { |ix| set_client_data(pos+ix, data[ix]) }
+        end
       else
-        wx_insert.bind(self).call(item, pos, data)
-        client_data_store.insert(pos, data)
+        itm_pos = wx_insert.bind(self).call(item, pos, data)
+        client_data_store.insert(itm_pos, data)
       end
     else
-      wx_insert.bind(self).call(item, pos)
       if ::Array === item
-        client_data_store.insert(pos, *::Array.new(item.size))
+        if sorted?
+          item.each_with_index do |itm, ix|
+            itm_pos = wx_insert.bind(self).call(itm)
+            client_data_store.insert(itm_pos, nil)
+          end
+        else
+          itm_pos = wx_insert.bind(self).call(item, pos)
+          client_data_store.insert(pos, *::Array.new(item.size))
+        end
       else
+        itm_pos = wx_insert.bind(self).call(item, pos)
         client_data_store.insert(pos, nil)
       end
     end
+    itm_pos
   end
 
   wx_set = instance_method :set

data/lib/wx/core/cursor.rb

@@ -2,7 +2,7 @@
 module Wx
 
   def self.Cursor(name, bmp_type = nil, *rest)
-    art_path = File.dirname(caller_path = caller_locations(1).first.absolute_path)
+    art_path = File.dirname(caller_path = caller_locations(1).first.absolute_path || caller_locations(1).first.path)
     art_owner = File.basename(caller_path, '.*')
     art_file = ArtLocator.find_art(name, art_type: :icon, art_path: art_path, art_section: art_owner, bmp_type: bmp_type)
     ::Kernel.raise ArgumentError, "Cannot locate art file for #{name}:Cursor" unless art_file