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

data/lib/wx/core/dc.rb

@@ -69,24 +69,4 @@ module Wx
 
   end
 
-  class MemoryDC
-
-    # convenience method for drawing on a temporary memory DC
-    def self.draw_on(arg)
-      dc = case arg
-           when Wx::Bitmap, Wx::DC
-             self.new(arg)
-           else
-             ::Kernel.raise ArgumentError, 'Expected Wx::Bitmap or Wx::DC'
-           end
-      begin
-        yield(dc) if block_given?
-      ensure
-        dc.select_object(Wx::NULL_BITMAP)
-      end
-      nil
-    end
-
-  end
-
 end

data/lib/wx/core/event_blocker.rb

@@ -0,0 +1,14 @@
+
+module Wx
+
+  class EventBlocker
+
+    class << self
+
+      alias :block_for :blocked_for
+
+    end
+
+  end
+
+end

data/lib/wx/core/evthandler.rb

@@ -17,9 +17,53 @@ class Wx::EvtHandler
 
   # Fast look-up hash to map event type ids to ruby event classes
   EVENT_TYPE_CLASS_MAP = {}
+  private_constant :EVENT_TYPE_CLASS_MAP
   # Hash to look up EVT constants from symbol names of evt handler
   # methods; used internally by disconnect (see EvtHandler.i)
   EVENT_NAME_TYPE_MAP = {}
+  private_constant :EVENT_NAME_TYPE_MAP
+  # Hash to look up event handler arity from symbol names of evt handler
+  # methods; internal use
+  EVENT_NAME_EVENT_ARITY_MAP = {}
+  private_constant :EVENT_NAME_EVENT_ARITY_MAP
+
+  class << self
+
+    def event_type_arity(name)
+      EVENT_NAME_EVENT_ARITY_MAP[name.to_sym] || 0
+    end
+
+    def get_event_type_class_map
+      EVENT_TYPE_CLASS_MAP
+    end
+    private :get_event_type_class_map
+
+    # Add caching for added event filters as we need to keep these alive
+    # for as long as they are registered
+
+    def event_filters
+      @event_filters ||= []
+    end
+    private :event_filters
+
+    wx_add_filter = instance_method :add_filter
+    define_method :add_filter do |filter|
+      wx_add_filter.bind(self).call(filter)
+      event_filters << filter
+    end
+
+    wx_remove_filter = instance_method :remove_filter
+    define_method :remove_filter do |filter|
+      wx_remove_filter.bind(self).call(filter)
+      event_filters.delete(filter)
+    end
+
+    def clear_filters
+      event_filters.each { |f| remove_filter(f) }
+      event_filters.clear
+    end
+
+  end
 
   # Given a Wx EventType id (eg Wx::EVT_MENU), returns a WxRuby Event
   # class which should be passed to event handler blocks. The actual
@@ -43,8 +87,8 @@ class Wx::EvtHandler
 
   # Given the Integer constant Wx::EVT_XXX, returns the convenience
   # handler method name associated with that type of event.
-  def self.event_name_for_type(name)
-    EVENT_NAME_TYPE_MAP.key(name)
+  def self.event_name_for_type(evt_id)
+    EVENT_NAME_TYPE_MAP.key(evt_id)
   end
 
   # Given an integer value +int_val+, returns the name of the EVT_xxx
@@ -85,6 +129,8 @@ class Wx::EvtHandler
       return
     end
 
+    EVENT_NAME_EVENT_ARITY_MAP[ev_type.name.to_sym] = ev_type.arity
+
     # set up the evt_xxx method
     case ev_type.arity
     when 0 # events without an id

data/lib/wx/core/find_replace_dialog.rb

@@ -0,0 +1,24 @@
+
+module Wx
+
+  class FindReplaceDialog < Wx::Dialog
+
+    # add caching for FindReplaceData object
+    # dialog does not take over ownership but does allow referencing
+    # the data object so we need to keep it alive here
+
+    wx_initialize = instance_method :initialize
+    define_method :initialize do |parent, data, *args|
+      wx_initialize.bind(self).call(parent, data, *args)
+      @fr_data = data
+    end
+
+    wx_set_data = instance_method :set_data
+    define_method :set_data do |data|
+      wx_set_data.bind(self).call(data)
+      @fr_data = data
+    end
+
+  end
+
+end

data/lib/wx/core/font.rb

@@ -1,22 +1,30 @@
 
 require_relative './font/encoding'
 
-class Wx::Font
-  class << self
-    # Returns the name of the platform's default font encoding 
-    def get_default_encoding_name
-      ENCODING_NAMES[ get_default_encoding ]
-    end
+module Wx
+
+  class Font
+    class << self
+      # Returns the name of the platform's default font encoding
+      def get_default_encoding_name
+        ENCODING_NAMES[ get_default_encoding ]
+      end
 
-    # Sets the default encoding to be +enc+, which may be the string
-    # name of an encoding (eg 'UTF8') or an internal WxWidgets flag 
-    # (eg Wx::FONTENCODING_UTF8).
-    def set_default_encoding_name(enc)
-      if flag_int = ENCODING_NAMES.index(enc.upcase)
-        set_default_encoding(Wx::FontEncoding.new(flag_int))
-      else
-        raise ArgumentError, "Unknown font encoding name '#{enc}'"
+      # Sets the default encoding to be +enc+, which may be the string
+      # name of an encoding (eg 'UTF8') or an internal WxWidgets flag
+      # (eg Wx::FONTENCODING_UTF8).
+      def set_default_encoding_name(enc)
+        if flag_int = ENCODING_NAMES.index(enc.upcase)
+          set_default_encoding(Wx::FontEncoding.new(flag_int))
+        else
+          raise ArgumentError, "Unknown font encoding name '#{enc}'"
+        end
       end
     end
   end
+
+  # make this simply an alias for the Font class so the #find_or_create_font methods
+  # can be accessed through that name too.
+  TheFontList = Font
+
 end

data/lib/wx/core/helpprovider.rb

@@ -6,9 +6,9 @@ class Wx::HelpProvider
     # SWIG Director; it can't be reaped and re-wrapped later. The
     # easiest way is to make the currently set one an instance variable
     # of this class
-    alias :__wx_set :set
+    wx_set = instance_method :set
     define_method(:set) do | help_provider |
-      __wx_set(help_provider)
+      wx_set.bind(self).call(help_provider)
       @__hp__ = help_provider
     end
   end

data/lib/wx/core/icon.rb

@@ -51,7 +51,7 @@ module Wx
   end
 
   def self.Icon(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}:Icon" unless art_file

data/lib/wx/core/image.rb

@@ -69,7 +69,7 @@ module Wx
   end
 
   def self.Image(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: :image, art_path: art_path, art_section: art_owner, bmp_type: bmp_type)
     ::Kernel.raise ArgumentError, "Cannot locate art file for #{name}:Image" unless art_file

data/lib/wx/core/menu.rb

@@ -75,4 +75,9 @@ class Wx::Menu
   methods_with_optional_ids_and_pos :insert,
                                     :insert_check_item,
                                     :insert_radio_item
+
+  # wxRuby2 backward compatibility version; no alias as #append has been altered above
+  def append_item(*args)
+    append(*args)
+  end
 end

data/lib/wx/core/paintdc.rb

@@ -0,0 +1,8 @@
+
+class Wx::PaintDC
+
+  def self.draw_on(win, &block)
+    win.paint(&block) if block
+  end
+
+end

data/lib/wx/core/pen.rb

@@ -0,0 +1,6 @@
+
+module Wx
+
+  ThePenList = Wx::Pen
+
+end

data/lib/wx/core/text_entry.rb

@@ -0,0 +1,15 @@
+
+module Wx
+
+  module TextEntry
+
+    wx_auto_complete = instance_method :auto_complete
+    define_method :auto_complete do |completer|
+      if wx_auto_complete.bind(self).call(completer)
+        @completer = completer # keep the Ruby object alive
+      end
+    end
+
+  end
+
+end

data/lib/wx/core/v_list_box.rb

@@ -0,0 +1,13 @@
+
+class Wx::VListBox
+
+  wx_each_selected = instance_method :each_selected
+  define_method :each_selected do |&block|
+    if block
+      wx_each_selected.bind(self).call(&block)
+    else
+      ::Enumerator.new { |y| wx_each_selected.bind(self).call { |sel| y << sel } }
+    end
+  end
+
+end

data/lib/wx/core/window.rb

@@ -1,5 +1,6 @@
 # Copyright 2004-2007 by Kevin Smith
-# released under the MIT-style wxruby2 license
+# Copyright 2022 by Martin Corino
+# released under the MIT(-style) wxruby2/3 license
 
 # The base class for all things displayed on screen
 class Wx::Window
@@ -49,7 +50,7 @@ class Wx::Window
   # This modified version of evt_paint sets a variable indicating that a
   # paint event is being handled just before running the event
   # handler. This ensures that any call to Window#paint within the
-  # handler will supply a Wx::PaintDC (see swig/Window.i).
+  # handler will supply a Wx::PaintDC (see Window SWIG director).
   def evt_paint(meth = nil, &block)
     paint_proc = acquire_handler(meth, block)
     wrapped_block = proc do | event |
@@ -69,4 +70,30 @@ class Wx::Window
       self.paint(&block)
     end
   end
+
+  # implement non-static variants of these
+
+  def from_dip(*args)
+    Wx::Window.from_dip(*args, self)
+  end
+  def to_dip(*args)
+    Wx::Window.to_dip(*args, self)
+  end
+
+  def from_phys(*args)
+    Wx::Window.from_phys(*args, self)
+  end
+  def to_phys(*args)
+    Wx::Window.to_phys(*args, self)
+  end
+
+  # implement Window update locker
+  def locked(&block)
+    self.freeze
+    begin
+      block.call if block_given?
+    ensure
+      self.thaw
+    end
+  end
 end

data/lib/wx/doc/app.rb

@@ -0,0 +1,40 @@
+
+class Wx::App
+
+  # Set the menu item id for the About menu item.
+  # Default is {Wx::ID_ABOUT}
+  # @param [Integer] id
+  def set_mac_about_menu_itemid(id) end
+  alias :mac_about_menu_itemid= :set_mac_about_menu_itemid
+  
+  # Get the current menu item id for the About menu item.
+  # Default is {Wx::ID_ABOUT}
+  # @return [Integer]
+  def get_mac_about_menu_itemid(id) end
+  alias :mac_about_menu_itemid :get_mac_about_menu_itemid
+
+  # Set the menu item id for the Preferences menu item.
+  # Default is {Wx::ID_PREFERENCES}
+  # @param [Integer] id
+  def set_mac_preferences_menu_itemid(id) end
+  alias :mac_preferences_menu_itemid= :set_mac_preferences_menu_itemid
+
+  # Get the current menu item id for the Preferences menu item.
+  # Default is {Wx::ID_PREFERENCES}
+  # @return [Integer]
+  def get_mac_preferences_menu_itemid(id) end
+  alias :mac_preferences_menu_itemid :get_mac_preferences_menu_itemid
+
+  # Set the menu item id for the Exit menu item.
+  # Default is {Wx::ID_EXIT}
+  # @param [Integer] id
+  def set_mac_exit_menu_itemid(id) end
+  alias :mac_exit_menu_itemid= :set_mac_exit_menu_itemid
+
+  # Get the current menu item id for the Exit menu item.
+  # Default is {Wx::ID_EXIT}
+  # @return [Integer]
+  def get_mac_exit_menu_itemid(id) end
+  alias :mac_exit_menu_itemid :get_mac_exit_menu_itemid
+  
+end

data/lib/wx/doc/brush.rb

@@ -0,0 +1,17 @@
+
+module Wx
+
+  class Brush
+
+    # Finds a brush with the specified attributes in the global list and returns it, else creates a new brush, adds it to the global brush list, and returns it.
+    # @param [Wx::Colour,String,Symbol] colour The Brush colour.
+    # @param [Wx::BrushStyle] style The brush style. See {Wx::BrushStyle} for a list of the styles.
+    # @return [Wx::Brush]
+    def self.find_or_create_brush(colour, style=Wx::BrushStyle::BRUSHSTYLE_SOLID) end
+
+  end
+
+  # In wxRuby this is simply an alias for the Brush class.
+  TheBrushList = Wx::Brush
+
+end

data/lib/wx/doc/busy_info.rb

@@ -0,0 +1,21 @@
+
+module Wx
+
+  class BusyInfo
+
+    # @overload busy(message, parent=nil)
+    #   Shows busy info window with message, blocks event handling and calls the given block
+    #   passing the BusyInfo instance as argument.
+    #   @param [String] message
+    #   @param [Wx::Window,nil] parent
+    #   @yieldparam [Wx::BusyInfo] bi BusyInfo instance
+    # @overload busy(busy_info)
+    #   Shows busy info window according to busy_info settings, blocks event handling and calls the given block
+    #   passing the BusyInfo instance as argument.
+    #   @param [Wx::BusyInfoFlags] busy_info
+    #   @yieldparam [Wx::BusyInfo] bi BusyInfo instance
+    def self.busy(*args) end
+
+  end
+
+end

data/lib/wx/doc/client_dc.rb

@@ -0,0 +1,28 @@
+
+module Wx
+
+  class ClientDC < Wx::DC
+
+    # Executes the given block providing a temporary (client) dc as
+    # it's single argument.
+    # @param [Wx::Window] win window to draw on
+    # @yieldparam [Wx::ClientDC] dc the ClientDC instance to paint on
+    # @return [Object] result of the block
+    def self.draw_on(win) end
+
+  end
+
+  class PaintDC < Wx::ClientDC
+
+    # Executes the given block providing a temporary dc as
+    # it's single argument.
+    # 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 instead.
+    # @param [Wx::Window] win window to draw on
+    # @yieldparam [Wx::PaintDC] dc the PaintDC instance to paint on
+    # @return [Object] result of the block
+    def self.draw_on(win) end
+
+  end
+
+end

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/font.rb

@@ -0,0 +1,27 @@
+
+class Wx
+  class Font
+
+    # @overload find_or_create_font(point_size, family, style, weight, underline=false, facename='', encoding=Wx::FontEncoding::FONTENCODING_DEFAULT)
+    #   Finds a font of the given specification in the global font list, or creates one and adds it to the list.
+    #   @param [Integer] point_size Size in points. See {Wx::Font#set_point_size} for more info.
+    #   @param [Wx::FontFamily] family The font family: a generic portable way of referring to fonts without specifying a facename.
+    #   @param [Wx::FontStyle] style One of {Wx::FontStyle::FONTSTYLE_NORMAL}, {Wx::FontStyle::FONTSTYLE_SLANT} and {Wx::FontStyle::FONTSTYLE_ITALIC}.
+    #   @param [Wx::FontWeight] weight Font weight, sometimes also referred to as font boldness. One of the {Wx::FontWeight} enumeration values.
+    #   @param [Boolean] underline The value can be true or false.
+    #   @param [String] facename An optional string specifying the face name to be used. If it is an empty string, a default face name will be chosen based on the family.
+    #   @param [Wx::FontEncoding] encoding An encoding which may be one of the enumeration values of {Wx::FontEncoding}. If the specified encoding isn't available, no font is created (see also Font Encodings).
+    #   @return [Wx::Font]
+    #   @see Wx::Font#initialize
+    # @overload find_or_create_font(font_info)
+    #   Finds a font of the given specification in the global font list, or creates one and adds it to the list.
+    #   @param [Wx::FontInfo] font_info
+    #   @return [Wx::Font]
+    def self.find_or_create_font(*args) end
+
+  end
+
+  # In wxRuby this is simply an alias for the Font class.
+  TheFontList = Font
+
+end