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

data/lib/wx/doc/controlwithitems.rb

@@ -0,0 +1,11 @@
+
+class Wx::ControlWithItems
+
+  # Returns true if the items in the control are sorted
+  # (style Wx::LB_SORT for list boxes or Wx::CB_SORT for combo boxes).
+  # This method is mostly meant for internal use only.
+  # @return [Boolean] true is sorted, false otherwise
+  def is_sorted; end
+  alias :sorted? :is_sorted
+
+end

data/lib/wx/doc/dc.rb

@@ -49,18 +49,4 @@ module Wx
 
   end
 
-  class MemoryDC
-
-    # Creates a Memory DC and passes that to the given block to draw on.
-    # Automatically unselects any source object of the MemoryDC after the block finishes.
-    # @overload self.draw_on(bitmap)
-    #   @param [Wx::Bitmap]
-    #   @yieldparam [WxMemoryDC] dc
-    # @overload self.draw_on(dc)
-    #   @param [Wx::DC]
-    #   @yieldparam [WxMemoryDC] dc
-    def self.draw_on(arg, &block) end
-
-  end
-
 end

data/lib/wx/doc/event_blocker.rb

@@ -0,0 +1,27 @@
+
+module Wx
+
+  class EventBlocker
+
+    class << self
+
+      # Constructs the blocker for the given window and for the given event type and passes the blocker to the
+      # given block. The blocker is destroyed after the block returns.
+      #
+      # If type is Wx::EVT_ANY, then all events for that window are blocked. You can call #block after creation to
+      # add other event types to the list of events to block.
+      #
+      # @note Note that the win window must remain alive until the given block returns (i.e. until Wx::EventBlocker's
+      # object destruction).
+      # @param [Wx::Window] win the window to block events for
+      # @param [Integer] evt_type the event type to block
+      # @yieldparam [Wx::EventBlocker] blkr the blocker object
+      # @return [Object] the value returned by the block
+      def blocked_for(win, evt_type=Wx::EVT_ANY) end
+      alias :block_for :blocked_for
+
+    end
+
+  end
+
+end

data/lib/wx/doc/evthandler.rb

@@ -3,6 +3,10 @@
 
 class Wx::EvtHandler
 
+  # Removes all (Ruby) installed EventFilter-s.
+  # @return [void]
+  def self.clear_filters; end
+
   # Public method to register the mapping of a custom event type
   # +konstant+ (which should be a unique integer; one will be created if
   # not supplied) to a custom event class +klass+. If +meth+ and +arity+

data/lib/wx/doc/extra/02_lifecycles.md

@@ -114,3 +114,52 @@ destroy these on a regular basis when not used (closed) possibly re-creating the
 
 Dialogs are special cases of toplevel windows which are not automatically destroyed when closed. The wxRuby library
 therefor provides special support to ease handling the destruction of these. See [here](03_dialogs.md) for more details.
+
+## Object identities
+
+One of the trickier things to handle correctly in the kind of native extensions like wxRuby is maintaining object 
+identities i.e. keeping native instances synced with their Ruby wrapper counter parts.
+
+Whenever a native extension is allowed to call back into Ruby space we encounter the problem the we need to map any 
+native object data provided for the call to the right Ruby types and when necessary to the right Ruby instance (object
+identity).
+
+Objects that are considered POD types (*plain old data* types) like numerics, booleans, strings, arrays and hashes do
+not require maintaining *object identity*. For these objects it is enough to map them to the right Ruby type before
+passing them on to Ruby space.
+
+For a lot of other objects though it is essential to not only map to the right **most derived** class type but also to
+the exact Ruby instance which was originally instantiated as wrapper for the native object if any exists (in case no
+Ruby instance existed yet a new instance of the correct **most derived** class should be instantiated at that point). 
+The reason this is important is 1. because the Ruby instance may have been used to identify, link to or otherwise 
+reference other data and/or functionality related to that specific Ruby/native pair and 2. the Ruby instance could 
+contain data elements (instance variables) related to that specific Ruby/native pair.<br>
+In the case of wxRuby Window instance for example it is common to derive custom Window classes with custom behaviour and
+corresponding instance variables that drive that behaviour. When an event handler or an overloaded native method is passed
+a native window object we absolutely need to be able to map that native object to the correct Ruby wrapper instance so
+all information stays in sync.
+
+For this purpose wxRuby uses *object tracking* i.e. maintaining hash tables mapping native object pointers to Ruby object 
+values. Whenever a tracked object is instantiated it is registered and can from than on be resolved whenever needed to map
+from native object to Ruby object.<br>
+Of course this also means wxRuby has to track object destruction so mappings can be removed when a native object is 
+destructed.<br>
+Additionally the tracking tables are also used to mark Ruby objects during the GC marking phase so they do not get garbage
+collected whenever they are not referenced in Ruby space anymore but still functioning in native space (this is for example
+a common situation for many child windows created but not permanently referenced in Ruby space).
+
+Tracking and resolving mappings from tracking tables produces a certain computing overhead but testing has shown this to be
+absolutely acceptable for normal applications.
+
+There are however quite a lot of wrapped native objects in wxRuby for which *object identity* is not essential. For these
+object tracking has been disabled for their classes. This means these kind of classes/object should **not** be derived from
+(if even possible and/or useful) to add functionality/information or their identity used as key to link other information.<br>
+These classes include:
+- classes considered POD types like Wx::Size, Wx::Point, Wx::RealPoint, Wx::Rect, Wx::GBSpan, Wx::GBPosition, Wx::BusyInfoFlags,
+Wx::AboutDialogInfo
+- final non-instantiatable classes like the Wx::DC (Device Context) class family, Wx::GraphicsContext, Wx::WindowsDisabler,
+Wx::EventBlocker, Wx::BusyInfo
+- classes with native singleton objects like Wx::Clipboard
+- the reference counted GDI objects like Wx::Pen, Wx::Brush, Wx::Colour, Wx::Cursor, Wx::Bitmap, Wx::Icon
+
+The reference documentation will note untracked object classes.

data/lib/wx/doc/extra/10_art.md

@@ -3,7 +3,7 @@
 # @title 10. wxRuby Locating and loading art
 -->
 
-# 9. wxRuby Locating and loading art
+# 10. wxRuby Locating and loading art
 
 ## Introduction
 

data/lib/wx/doc/extra/11_drawing_and_dc.md

@@ -0,0 +1,62 @@
+<!--
+# @markup markdown
+# @title 11. wxRuby Drawing and Device Contexts
+-->
+
+# 11. wxRuby Drawing and Device Contexts (DC)
+
+In wxRuby the Wx::DC class family provides functionality for drawing to windows, bitmaps, printers etc.
+
+What most of these classes have in common is that actual drawing output is buffered until the time the 
+device context object is destroyed.
+For this reason the common practice in wxWidgets C++ code would be to create temporary DC objects on the
+stack and draw on them while they are in scope (for several classes it is even strongly advised to never create
+them any other way and to never keep objects alive out of scope). When leaving the scope these object would than be 
+automatically destroyed and the any buffered output flushed to the final target.
+
+In Ruby this approach is impossible as Ruby is a purely dynamic language and does not **this kind** of scope bound
+life cycles. Any DC object created would have to be dynamically created and due to the properties of the GC driven
+life cycles could well be kept alive beyond the scope of it's creation. This will not always cause problems but could
+and does not really have an upside.
+
+To prevent confusion and potential problems wxRuby defines all `Wx::DC` derived classes to be abstract classes that
+cannot be instantiated using `new`. Rather all `Wx::DC` derived classes provide `::draw_on` factory methods to create 
+temporary dc objects that will be passed on to blocks given and will only exist for the duration of the execution of
+the block. This will guarantee proper DC cleanup when leaving it's usage scope.
+
+> Note that it is a **BAD** idea to think about storing the dc reference provide to the block for later access!
+
+A typical usage of a `::draw_on` method would be:
+
+```ruby
+    myTestBitmap1x = Wx::Bitmap.new(60, 15, 32)
+    Wx::MemoryDC.draw_on(myTestBitmap1x) do |mdc|
+      mdc.set_background(Wx::WHITE_BRUSH)
+      mdc.clear
+      mdc.set_pen(Wx::BLACK_PEN)
+      mdc.set_brush(Wx::WHITE_BRUSH)
+      mdc.draw_rectangle(0, 0, 60, 15)
+      mdc.draw_line(0, 0, 59, 14)
+      mdc.set_text_foreground(Wx::BLACK)
+      mdc.draw_text("x1", 0, 0)
+    end
+```
+
+## Windows, Wx::PaintDC and Wx::AutoBufferedPaintDC
+
+The `Wx::PaintDC` and `Wx::AutoBufferedPaintDC` classes provide `::draw_on` methods just like all other DC classes but
+this is mostly to be consistent.
+
+In this case it is recommended to instead use the `Wx::Window#paint` or `Wx::Window#paint_buffered` methods as these
+provide some optimizations with regard to automatically detecting is the methods are called inside `Wx::EVT_PAINT` 
+handlers (which should normally be the case) or not.
+
+So the typical way to do buffered painting inside a windows `Wx::EVT_PAINT` handler would be something like:
+
+```ruby
+  def on_paint(_event)
+    self.paint_buffered do |dc|
+      # ... do some drawing ...
+    end
+  end
+```

data/lib/wx/doc/memory_dc.rb

@@ -0,0 +1,75 @@
+
+module Wx
+
+  class MemoryDC < Wx::DC
+
+    # Creates a Memory DC and passes that to the given block to draw on.
+    # Automatically unselects any source object of the MemoryDC after the block finishes.
+    # @overload self.draw_on()
+    #   @yieldparam [Wx::MemoryDC] dc
+    # @overload self.draw_on(bitmap)
+    #   @param [Wx::Bitmap]
+    #   @yieldparam [Wx::MemoryDC] dc
+    # @overload self.draw_on(dc)
+    #   @param [Wx::DC]
+    #   @yieldparam [Wx::MemoryDC] dc
+    def self.draw_on(*arg) end
+
+  end
+
+  class BufferedDC < Wx::MemoryDC
+
+    # Creates a Buffered DC and passes that to the given block to draw on.
+    # Destroys the DC after the block returns.
+    # @overload self.draw_on()
+    #   Creates a buffer for the provided dc.
+    #   @yieldparam [Wx::BufferedDC] dc
+    # @overload self.draw_on(tgt, area, style=Wx::BUFFER_CLIENT_AREA)
+    #   Creates a buffer for the provided dc. #init must not be called when using this constructor.
+    #   @param [Wx::DC] tgt The underlying DC: everything drawn to this object will be flushed to this DC when this object is destroyed. You may pass nil in order to just initialize the buffer, and not flush it.
+    #   @param [Wx::Size] area The size of the bitmap to be used for buffering (this bitmap is created internally when it is not given explicitly).
+    #   @param [Integer] style Wx::BUFFER_CLIENT_AREA to indicate that just the client area of the window is buffered, or Wx::BUFFER_VIRTUAL_AREA to indicate that the buffer bitmap covers the virtual area.
+    #   @yieldparam [Wx::BufferedDC] dc
+    # @overload self.draw_on(tgt, buffer=Wx::NULL_BITMAP, style=Wx::BUFFER_CLIENT_AREA)
+    #   Creates a buffer for the provided dc. #init must not be called when using this constructor.
+    #   @param [Wx::DC] tgt The underlying DC: everything drawn to this object will be flushed to this DC when this object is destroyed. You may pass nil in order to just initialize the buffer, and not flush it.
+    #   @param [Wx::Bitmap] buffer Explicitly provided bitmap to be used for buffering: this is the most efficient solution as the bitmap doesn't have to be recreated each time but it also requires more memory as the bitmap is never freed. The bitmap should have appropriate size, anything drawn outside of its bounds is clipped.
+    #   @param [Integer] style Wx::BUFFER_CLIENT_AREA to indicate that just the client area of the window is buffered, or Wx::BUFFER_VIRTUAL_AREA to indicate that the buffer bitmap covers the virtual area.
+    #   @yieldparam [Wx::BufferedDC] dc
+    def self.draw_on(*arg) end
+
+  end
+
+  class BufferedPaintDC < Wx::BufferedDC
+
+    # Creates a Buffered DC and passes that to the given block to draw on.
+    # Destroys the DC after the block returns.
+    # As with Wx::BufferedDC, you may either provide the bitmap to be used for buffering or let this object create one internally (in the latter case, the size of the client part of the window is used).
+    #
+    # Pass W::xBUFFER_CLIENT_AREA for the style parameter to indicate that just the client area of the window is buffered, or Wx::BUFFER_VIRTUAL_AREA to indicate that the buffer bitmap covers the virtual area.
+    # @overload self.draw_on(win, style=Wx::BUFFER_CLIENT_AREA)
+    #   @param [Wx::Window] win The underlying window; everything drawn to this object will be flushed to this window when this object is destroyed.
+    #   @param [Integer] style Wx::BUFFER_CLIENT_AREA to indicate that just the client area of the window is buffered, or Wx::BUFFER_VIRTUAL_AREA to indicate that the buffer bitmap covers the virtual area.
+    #   @yieldparam [Wx::BufferedPaintDC] dc
+    # @overload self.draw_on(win, buffer=Wx::NULL_BITMAP, style=Wx::BUFFER_CLIENT_AREA)
+    #   @param [Wx::Window] win The underlying window; everything drawn to this object will be flushed to this window when this object is destroyed.
+    #   @param [Wx::Bitmap] buffer Explicitly provided bitmap to be used for buffering: this is the most efficient solution as the bitmap doesn't have to be recreated each time but it also requires more memory as the bitmap is never freed. The bitmap should have appropriate size, anything drawn outside of its bounds is clipped.
+    #   @param [Integer] style Wx::BUFFER_CLIENT_AREA to indicate that just the client area of the window is buffered, or Wx::BUFFER_VIRTUAL_AREA to indicate that the buffer bitmap covers the virtual area.
+    #   @yieldparam [Wx::BufferedPaintDC] dc
+    def self.draw_on(*arg) end
+
+  end
+
+  class AutoBufferedPaintDC < Wx::BufferedPaintDC
+
+    # Creates a Buffered DC and passes that to the given block to draw on.
+    # Destroys the DC after the block returns.
+    # Pass a pointer to the window on which you wish to paint.
+    # @note In wxRuby this method mostly exists to be consistent with the other DC classes. It is however recommended to use Wx::Window#paint_buffered instead.
+    # @param [Wx::Window] win The underlying window; everything drawn to this object will be flushed to this window when this object is destroyed.
+    # @yieldparam [Wx::AutoBufferedPaintDC] dc
+    def self.draw_on(win, &block) end
+
+  end
+
+end

data/lib/wx/doc/mirror_dc.rb

@@ -0,0 +1,16 @@
+
+module Wx
+
+  class MirrorDC < Wx::DC
+
+    # Executes the given block providing a temporary (mirror) dc as
+    # it's single argument.
+    # @param [Wx::DC] dc DC to duplicate the (mirrored) drawing on
+    # @param [Boolean] mirror whether to mirror or not
+    # @yieldparam [Wx::MirrorDC] dc the MirrorDC instance to paint on
+    # @return [Object] result of the block
+    def self.draw_on(dc, mirror) end
+
+  end
+
+end

data/lib/wx/doc/prt/printer_dc.rb

@@ -0,0 +1,26 @@
+
+module Wx::PRT
+
+  class PrinterDC < Wx::DC
+
+    # Executes the given block providing a temporary (printer) dc as
+    # it's single argument.
+    # @param [Wx::PRT::PrintData] print_data print_data defining the print settings
+    # @yieldparam [Wx::PrinterDC] dc the PrinterDC instance to paint on
+    # @return [Object] result of the block
+    def self.draw_on(win) end
+
+  end
+
+  class PostScriptDC < Wx::DC
+
+    # Executes the given block providing a temporary (postscript) dc as
+    # it's single argument.
+    # @param [Wx::PRT::PrintData] print_data print_data defining the print settings
+    # @yieldparam [Wx::PostScriptDC] dc the PostScriptDC instance to paint on
+    # @return [Object] result of the block
+    def self.draw_on(win) end
+
+  end
+
+end

data/lib/wx/doc/screen_dc.rb

@@ -1,10 +1,14 @@
 
-class Wx::ScreenDC
+module Wx
 
-  # Executes the given block providing a temporary (screen) dc as
-  # it's single argument.
-  # @yieldparam [Wx::ScreenDC] dc the ScreenDC instance to paint on
-  # @return [Object] result of the block
-  def self.paint; end
+  class ScreenDC < Wx::DC
+
+    # Executes the given block providing a temporary (screen) dc as
+    # it's single argument.
+    # @yieldparam [Wx::ScreenDC] dc the ScreenDC instance to paint on
+    # @return [Object] result of the block
+    def self.draw_on; end
+
+  end
 
 end

data/lib/wx/doc/svg_file_dc.rb

@@ -0,0 +1,20 @@
+
+module Wx
+
+  class SVGFileDC < Wx::DC
+
+    # Executes the given block providing a temporary dc as it's single argument.
+    # Initializes a wxSVGFileDC with the given filename, width and height at dpi resolution, and an optional title.
+    # The title provides a readable name for the SVG document.
+    # @param [String] filename name of file to create
+    # @param [Integer] width width for SVG image
+    # @param [Integer] height height for SVG image
+    # @param [Float] dpi resolution for SVG image
+    # @param [String] title readable name for the SVG document
+    # @yieldparam [Wx::SVGFileDC] dc the SVGFileDC instance to paint on
+    # @return [Object] result of the block
+    def self.draw_on(filename, width=320, height=240, dpi=72, title='') end
+
+  end
+
+end

data/lib/wx/doc/v_list_box.rb

@@ -0,0 +1,9 @@
+
+class Wx::VListBox
+
+  # Iterate selected items. Returns Enumerator if no block given.
+  # @yieldparam [Integer] sel selected item index
+  # @return [Enumerator,Object] if block given returns last return value of block, Enumerator otherwise
+  def each_selected; end
+
+end

data/lib/wx/doc/window_disabler.rb

@@ -0,0 +1,10 @@
+
+class Wx::WindowDisabler
+
+  # Disables all top level windows of the application (maybe with the exception of one of them) in
+  # and enables them back after the given block has returned.
+  # @param [Wx::Window,nil] to_skip window to exclude from disabling
+  # @return [void]
+  def self.disable(to_skip = nil) end
+
+end

data/lib/wx/html/keyword_defs.rb

@@ -10,13 +10,12 @@ Wx::define_keyword_ctors(Wx::HTML::HtmlWindow) do
 end
 
 # wxHtmlListBox 	A listbox showing HTML content
-# wxListBox 	A list of strings for single or multiple selection
-Wx::define_keyword_ctors('ListBox') do
-  wx_ctor_params :id, :pos, :size, :choices => []
-  wx_ctor_params :style
-  wx_ctor_params :validator, :name => 'listBox'
+Wx::define_keyword_ctors(Wx::HTML::HtmlListBox) do
+  wx_ctor_params :id, :pos, :size, :style, :name => 'HtmlListBox'
 end
 
-Wx::define_keyword_ctors('HtmlListBox') do
-  wx_ctor_params :id, :pos, :size, :style, :name => 'HtmlListBoxNameStr'
+Wx::define_keyword_ctors(Wx::HTML::SimpleHtmlListBox) do
+  wx_ctor_params :id, :pos, :size
+  wx_ctor_params :choices => []
+  wx_ctor_params :style, :validator, :name => 'SimpleHtmlListBox'
 end

data/lib/wx/html/require.rb

@@ -6,5 +6,6 @@ require_relative './events/evt_list'
 require_relative './keyword_defs'
 require_relative './htmlwindow'
 require_relative './htmlhelpcontroller'
+require_relative './simple_html_listbox'
 
 Wx::Dialog.setup_dialog_functors(Wx::HTML)

data/lib/wx/html/simple_html_listbox.rb

@@ -0,0 +1,105 @@
+
+class Wx::HTML::SimpleHtmlListBox
+
+  # Make this a Ruby enumerable so find, find_all, map etc are available
+  include Enumerable
+
+  # Passes each valid item index into the passed block
+  def each
+    get_count.times { | i | yield i }
+  end
+
+  # 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.
+
+  def client_data_store
+    @client_data ||= []
+  end
+  private :client_data_store
+
+  wx_set_client_data = instance_method :set_client_data
+  define_method :set_client_data do |item, data|
+    item = item.to_i
+    wx_set_client_data.bind(self).call(item, data)
+    client_data_store[item] = data
+  end
+
+  def get_client_data(item)
+    client_data_store[item.to_i]
+  end
+
+  wx_append = instance_method :append
+  define_method :append do |item, data=nil|
+    if data
+      if ::Array === item
+        if !(::Array === data)
+          ::Kernel.raise ::TypeError.new("Expected Array for argument 3")
+        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]) }
+      else
+        wx_append.bind(self).call(item, data)
+        client_data_store[get_count-1] = data
+      end
+    else
+      wx_append.bind(self).call(item)
+      # no changes to data store
+    end
+  end
+
+  wx_insert = instance_method :insert
+  define_method :insert do |item, pos, data=nil|
+    if data
+      if ::Array === item
+        if !(::Array === data)
+          ::Kernel.raise ::TypeError.new("Expected Array for argument 3")
+        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]) }
+      else
+        wx_insert.bind(self).call(item, pos, data)
+        client_data_store.insert(pos, data)
+      end
+    else
+      wx_insert.bind(self).call(item, pos)
+      if ::Array === item
+        client_data_store.insert(pos, *::Array.new(item.size))
+      else
+        client_data_store.insert(pos, nil)
+      end
+    end
+  end
+
+  wx_set = instance_method :set
+  define_method :set do |items, data=nil|
+    if data
+      if !(::Array === data)
+        ::Kernel.raise ::TypeError.new("Expected Array for argument 2")
+      elsif data.size != items.size
+        ::Kernel.raise ::ArgumentError.new("items and data array must be equal size")
+      end
+    end
+    wx_set.bind(self).call(items)
+    client_data_store.clear
+    items.each_with_index { |item, ix| set_client_data(item, data[ix]) }
+  end
+
+  wx_clear = instance_method :clear
+  define_method :clear do
+    wx_clear.bind(self).call
+    client_data_store.clear
+  end
+
+  wx_delete = instance_method :delete
+  define_method :delete do |item|
+    wx_delete.bind(self).call(item.to_i)
+    client_data_store.slice!(item.to_i)
+  end
+end

data/lib/wx/keyword_defs.rb

@@ -296,6 +296,13 @@ Wx::define_keyword_ctors('CheckBox') do
   wx_ctor_params :validator, :name => 'checkBox'
 end
 
+# wxListBox 	A list of strings for single or multiple selection
+Wx::define_keyword_ctors('ListBox') do
+  wx_ctor_params :id, :pos, :size, :choices => []
+  wx_ctor_params :style
+  wx_ctor_params :validator, :name => 'listBox'
+end
+
 # A listbox with a checkbox to the left of each item
 Wx::define_keyword_ctors('CheckListBox') do
   wx_ctor_params :id, :pos, :size, :choices, :style

data/lib/wx/version.rb

@@ -1,3 +1,3 @@
 module Wx
-  WXRUBY_VERSION    = '0.9.0-beta.14'
+  WXRUBY_VERSION    = '0.9.0-rc.1'
 end

data/lib/wx/wxruby/cmd/test.rb

@@ -16,7 +16,7 @@ module WxRuby
           description
         else
           Dir[File.join(WxRuby::ROOT, 'tests', '*.rb')].each do |test|
-            system(RUBY, test)
+            exit(1) unless system(RUBY, test)
           end
         end
       end

data/rakelib/install.rb

@@ -34,7 +34,9 @@ module WXRuby3
                   grp_id = m[1]
                   lib_id = m[2]
                   ver = m[3].sub('.', '')
-                  lib = "wx#{grp_id.sub(/u\Z/, '')}#{ver}u#{lib_id}"
+                  # as of wxw 3.3 there seems to be an additional digit added to the version part of the dll name
+                  # so add a wildcard ('*') in that spot to match older and newer versions
+                  lib = "wx#{grp_id.sub(/u\Z/, '')}#{ver}*u#{lib_id}"
                   @wxwin_shlibs.include File.join(libdir, "#{lib}*.#{WXRuby3.config.dll_mask}")
                 end
               else

data/rakelib/lib/core/mapping.rb

@@ -223,13 +223,13 @@ module WXRuby3
         def map_to(typedef)
           if ::Hash === typedef
             typedef.each_pair do |argmasks, type|
-              pattern = @patterns.detect { |ps| ps == argmasks }
+              pattern = @map.patterns.detect { |ps| ps == argmasks }
               raise "Unknown parameter set [#{argmasks}] for [#{@map}]" unless pattern
-              @to[pattern] = type
+              @to[pattern] = _get_mapped_type(type)
             end
           else
-            @patterns.inject(@to) do |map, pattern|
-              map[pattern] = typedef
+            @map.patterns.inject(@to) do |map, pattern|
+              map[pattern] = _get_mapped_type(typedef)
               map
             end
           end
@@ -422,7 +422,7 @@ module WXRuby3
       end
 
       def map_out(ignore: nil, to: nil, temp: nil, code: nil, &block)
-        @out = Out.new(self, ignore: ignore, to: nil, temp: temp, code: code, &block)
+        @out = Out.new(self, ignore: ignore, to: to, temp: temp, code: code, &block)
       end
 
       def map_freearg(temp: nil, code: nil, &block)

data/rakelib/lib/core/spec.rb

@@ -250,12 +250,12 @@ module WXRuby3
         self
       end
 
-      def gc_as_temporary(*names)
+      def gc_as_untracked(*names)
         if names.empty?
-          @gc_type = :GC_MANAGE_AS_TEMP
+          @gc_type = :GC_MANAGE_AS_UNTRACKED
         else
           @gc_type = ::Hash.new unless @gc_type.is_a?(::Hash)
-          names.each {|n| @gc_type[n] = :GC_MANAGE_AS_TEMP }
+          names.each {|n| @gc_type[n] = :GC_MANAGE_AS_UNTRACKED }
         end
         self
       end
@@ -291,6 +291,10 @@ module WXRuby3
         @abstracts.has_key?(cls) && !@abstracts[cls]
       end
 
+      def concretes
+        @abstracts.keys.select { |cls| concrete?(cls) }
+      end
+
       def mixin?(cls)
         @mixins.include?(cls)
       end

data/rakelib/lib/core/spec_helper.rb

@@ -153,6 +153,10 @@ module WXRuby3
       ifspec.abstract?(class_def.name) || (class_def.abstract && !ifspec.concrete?(class_def.name))
     end
 
+    def explicit_concretes
+      ifspec.concretes
+    end
+
     def mixins
       ifspec.mixins
     end
@@ -183,12 +187,16 @@ module WXRuby3
           return :GC_MANAGE_AS_SIZER if classdef.is_derived_from?('wxSizer') || classdef.name == 'wxSizer'
           return :GC_MANAGE_AS_REFCOUNTED if classdef.is_derived_from?('wxRefCounter')
           return :GC_MANAGE_AS_OBJECT if classdef.is_derived_from?('wxObject') || classdef.name == 'wxObject'
-          return :GC_MANAGE_AS_TEMP
+          return :GC_MANAGE_AS_UNTRACKED
         end
       end
       ifspec.gc_type(classdef.name) || :GC_NEVER
     end
 
+    def is_tracked?(classdef)
+      gc_type(classdef) != :GC_MANAGE_AS_UNTRACKED
+    end
+
     def includes
       ifspec.includes
     end

data/rakelib/lib/director/accelerator.rb

@@ -37,7 +37,7 @@ module WXRuby3
             }
           }
           __HEREDOC
-        spec.map 'int keyCode' => 'Integer' do
+        spec.map 'int keyCode' => 'Integer,String' do
           map_in code: '$1 = wxRuby_RubyStringOrIntToKeyCode($input);'
           map_typecheck precedence: 'INT32', code: <<~__CODE
             $1 = ( (TYPE($input) == T_FIXNUM) || wxRuby_IsAnEnum($input) ||