wxruby3 1.7.0 → 1.8.1

data/ext/wxruby3/swig/memory_management.i

@@ -9,31 +9,11 @@
 // This file, required by common.i defines a set of macros which are used
 // to specify memory management strategies for individual Wx classes.
 
-// Broadly speaking there are two different strategies:
-//
-// 1) For all classes which inherit from Wx::Window, including all Frames,
-//    Dialogs and Controls: the C++ objects are managed by WxWidgets; when=
-//    Frame is closed, it and all its contents are deleted. Therefore wxRuby
-//    doesn't try to delete these objects as part of GC until they are known
-//    to have been deleted. The instance of Wx::App watches for window
-//    destruction, and in the GC-mark phase marks all Windows that are still
-//    alive. [see App.i]
-//
-// 2) Almost all other classes are memory managed by wxRuby - that is, when
-//    they have fallen out of scope and GC is run, the underlying C++ object
-//    will be deleted too by the standard %freefunc.
-
-
 // These are implemented in swig/wx.i, so they are shared among all classes
 %{
-WXRUBY_EXPORT void GcNullFreeFunc(void *);
-WXRUBY_EXPORT void GcSizerFreeFunc(void *);
-WXRUBY_EXPORT void GcDialogFreeFunc(void *);
 WXRUBY_EXPORT void GcRefCountedFreeFunc(void *);
 WXRUBY_EXPORT void GC_mark_wxSizer(void *);
-WXRUBY_EXPORT void GC_mark_attached_wxMenu(void *);
 WXRUBY_EXPORT void GC_mark_wxWindow(void *);
-WXRUBY_EXPORT void GC_mark_wxFrame(void *);
 WXRUBY_EXPORT void GC_mark_wxEvent(void *);
 %}
 
@@ -43,7 +23,7 @@ WXRUBY_EXPORT void GC_mark_wxEvent(void *);
 // all Windows, including Frames and Dialogs
 %define GC_NEVER(kls)
 %trackobjects kls;
-%feature("freefunc") kls "GcNullFreeFunc";
+%feature("freefunc") kls "SWIG_RubyRemoveTracking";
 %enddef
 
 // Strategy for windows that aren't top-level windows.  Here, the C++
@@ -61,26 +41,21 @@ GC_NEVER(kls);
 %enddef
 
 // Strategy for top-level frames - these are destroyed
-// automatically. Marking is the same as for Windows, plus preservation
-// of the associated MenuBar, if reuqired.
+// automatically. Marking is the same as for Windows.
 %define GC_MANAGE_AS_FRAME(kls)
-GC_NEVER(kls);
-// Mark any associated sizer
-%feature("markfunc") kls "GC_mark_wxFrame";
+GC_MANAGE_AS_WINDOW(kls);
 %enddef
 
 // Strategy for dialogs - these are NOT destroyed automatically
 %define GC_MANAGE_AS_DIALOG(kls)
-GC_NEVER(kls);
-// Mark any associated sizer
-%feature("markfunc") kls "GC_mark_wxWindow";
+GC_MANAGE_AS_WINDOW(kls);
 %enddef
 
 // Events - most are created within wxWidgets C++ on the stack and thus
 // do not need deletion. These are passed into ruby via EvtHandler or
 // App methods, and are wrapped using wxRuby_WrapWxEventInRuby (see
-// wx.i). This gives them a void freefunc and markfunc and are NOT
-// tracked - they are treated as one-shot short-lived objects.
+// wx.i). This gives them a null freefunc and markfunc and provides no
+// tracking - they are treated as one-shot short-lived objects.
  //
 // However, custom events created on the ruby side need to be deleted to
 // avoid leakage as SWIG wrappers call C++ "new" to allocate the
@@ -113,15 +88,10 @@ GC_NEVER(kls);
 %define GC_MANAGE_AS_MARKED(kls)
 %enddef
 
-// Sizers attached to windows are automatically destroyed by wxWidgets,
-// so they should not be deleted.
-//
-// TODO - orphaned/unattached sizers are not automatically destroyed -
-// so the freefunc should check for this condition and do the delete if
-// required to prevent a memory leak.
+// Attached sizers should only be marked by the window they are attached to.
 %define GC_MANAGE_AS_SIZER(kls)
 %trackobjects kls;
-%feature("freefunc") kls "GcSizerFreeFunc";
+//%feature("freefunc") kls "GcSizerFreeFunc";
 %feature("markfunc") kls "GC_mark_wxSizer";
 %enddef
 
@@ -133,12 +103,6 @@ GC_NEVER(kls);
 %feature("freefunc") kls "GcRefCountedFreeFunc";
 %enddef
 
-// special refcounted for grid cell renderers/editors and attrs
-%define GC_MANAGE_AS_UNTRACKED_REFCOUNTED(kls)
-%feature("freefunc") kls "GcRefCountedFreeFunc";
-%enddef
-
-
 // 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

data/ext/wxruby3/swig/wx.i

@@ -17,13 +17,15 @@
 
 #include <wx/filesys.h>
 #include <wx/fs_zip.h>
+#include <wx/utils.h>
 
 #include <unordered_map>
 
-WXRUBY_TRACE_GUARD(WxRubyTraceGCTrack, "GC_TRACK")
 WXRUBY_TRACE_GUARD(WxRubyTraceGCWrapEvents, "GC_WRAP_EVENTS")
 WXRUBY_TRACE_GUARD(WxRubyTraceGCWrapObject, "GC_WRAP_OBJECT")
 
+// SWIG and wxRuby3 custom tracking support
+#include "wxruby-GCTracking.h"
 %}
 
 // Some common functions
@@ -82,73 +84,6 @@ 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.
-// We don't want to use any functionality that could interfere with
-// Ruby GC handling so we use standard C++ hash maps.
-typedef std::unordered_map<void*, VALUE> PtrToRbObjHash;
-PtrToRbObjHash Global_Ptr_Map;
-
-// Add a tracking from ptr -> object
-WXRUBY_EXPORT void wxRuby_AddTracking(void* ptr, VALUE object)
-{
-  WXRUBY_TRACE_IF(WxRubyTraceGCTrack, 2)
-    WXRUBY_TRACE_WITH(VALUE clsname = rb_mod_name(CLASS_OF(object)))
-    WXRUBY_TRACE("> wxRuby_AddTracking" << std::flush <<
-                   "(" << ptr << ":{"
-                       << (clsname != Qnil ? StringValueCStr(clsname) : "<noname>")
-                       << "}, " << object << ")")
-  WXRUBY_TRACE_END
-
-  // Check if an 'old' tracking registry exists.
-  if (Global_Ptr_Map.count(ptr) == 1)
-  {
-    // This can happen if the C++ referenced by a Ruby object is managed by
-    // a wxWidgets object and deleted without unlinking the Ruby object.
-    // In these cases we unlink the previously linked Ruby object here
-    // (if not the same Ruby object which should not be possible).
-    // This will prevent SIGSEGV when attempting to call anything for
-    // these objects but instead cause more informative exceptions.
-    VALUE old_obj = Global_Ptr_Map[ptr];
-    if (!NIL_P(old_obj) && old_obj != object)
-    {
-      DATA_PTR(old_obj) = 0;
-    }
-
-  }
-  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)
-{
-  WXRUBY_TRACE_IF(WxRubyTraceGCTrack, 2)
-    WXRUBY_TRACE("< wxRuby_RemoveTracking(" << ptr << ") -> " << wxRuby_FindTracking(ptr))
-  WXRUBY_TRACE_END
-  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
@@ -259,6 +194,18 @@ WXRUBY_EXPORT VALUE wxRuby_WrapWxObjectInRuby(wxObject *wx_obj)
 static VALUE Evt_Type_Map = NULL;
 static VALUE WxRuby_cAsyncProcCallEvent = Qnil;
 
+inline VALUE _get_ThreadEventClass()
+{
+  static VALUE __cThreadEvent = Qnil;
+
+  if (RB_NIL_P(__cThreadEvent))
+  {
+    VALUE module = rb_const_get(wxRuby_Core(), rb_intern("RT"));
+    if (!RB_NIL_P(module)) __cThreadEvent = rb_const_get(module, rb_intern("ThreadEvent"));
+  }
+  return __cThreadEvent;
+}
+
 #ifdef __WXRB_DEBUG__
 WXRUBY_EXPORT VALUE wxRuby_WrapWxEventInRuby(void* rcvr, wxEvent *wx_event)
 #else
@@ -338,17 +285,41 @@ WXRUBY_EXPORT VALUE wxRuby_WrapWxEventInRuby(wxEvent *wx_event)
   DATA_PTR(rb_event) = wx_event;
   // do not forget to mark the instance with the mangled swig type name
   // (as there is no swig_type for the Wx::AsyncProcCallEvent class use it's base Wx::Event)
-  swig_type_info*  type = wx_event->GetEventType() == wxEVT_ASYNC_METHOD_CALL ?
-                            wxRuby_GetSwigTypeForClass(wxRuby_GetDefaultEventClass()) :
-                            wxRuby_GetSwigTypeForClass(rb_event_class);
-  rb_iv_set(rb_event, "@__swigtype__", rb_str_new2(type->name));
+  swig_type_info*  type;
+  if (wx_event->GetEventType() == wxEVT_ASYNC_METHOD_CALL)
+  {
+    type = wxRuby_GetSwigTypeForClass(wxRuby_GetDefaultEventClass());
+  }
+  else
+  {
+    type = wxRuby_GetSwigTypeForClass(rb_event_class);
+    if (!type)
+    {
+      // could be derived ThreadEvent
+      VALUE klass = _get_ThreadEventClass();
+      if (!RB_NIL_P(klass) && rb_class_inherited_p(rb_event_class, klass))
+      {
+        type = wxRuby_GetSwigTypeForClass(klass);
+      }
+    }
+  }
+  // type should never be null but let's be paranoid
+  if (type) rb_iv_set(rb_event, "@__swigtype__", rb_str_new2(type->name));
 
   WXRUBY_TRACE_IF(WxRubyTraceGCWrapEvents, 2)
-    WXRUBY_TRACE("< wxRuby_WrapWxEventInRuby - wrapped transitory event " << wx_event << "{" << type->name << "}")
+    WXRUBY_TRACE("< wxRuby_WrapWxEventInRuby - wrapped transitory event " << wx_event << "{" << (type ? type->name : rb_class2name(rb_event_class)) << "}")
   WXRUBY_TRACE_END
 
   return rb_event;
 }
+
+static VALUE wxruby_get_wx_prefix(int argc, VALUE *argv, VALUE self)
+{
+  if ((argc < 0) || (argc > 0)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); return Qnil;
+  }
+  return WXSTR_TO_RSTR(wxGetInstallPrefix());
+}
 %}
 
 %constant int wxWXWIDGETS_DEBUG_LEVEL = wxDEBUG_LEVEL;
@@ -364,4 +335,6 @@ WXRUBY_EXPORT VALUE wxRuby_WrapWxEventInRuby(wxEvent *wx_event)
 
 	// This is needed so HtmlHelp can load docs from a zip file
 	wxFileSystem::AddHandler(new wxArchiveFSHandler);
+
+	rb_define_module_function(mWxruby3, "get_wx_prefix", VALUEFUNC(wxruby_get_wx_prefix), -1);
 %}

data/lib/wx/core/const.rb

@@ -23,7 +23,6 @@ module Wx
   FRAME_NAME_STR = 'frame'
   STATUS_LINE_NAME_STR = 'status_line'
   STATIC_BITMAP_NAME_STR = 'staticBitmap'
-  WEB_VIEW_NAME_STR = 'wxWebView'
   ANIMATION_CTRL_NAME_STR = 'animationctrl'
   TOOL_BAR_NAME_STR = 'toolbar'
   TEXT_CTRL_NAME_STR = 'text'

data/lib/wx/core/context_help.rb

@@ -0,0 +1,17 @@
+# Copyright (c) 2023 M.J.N. Corino, The Netherlands
+#
+# This software is released under the MIT license.
+
+module Wx
+
+  class << self
+
+    define_method :ContextHelp do |window = nil|
+
+      context_help(window)
+
+    end
+
+  end
+
+end

data/lib/wx/core/cursor.rb

@@ -24,6 +24,7 @@ module Wx
 
       wx_set_cursor = instance_method :set_cursor
       wx_redefine_method :set_cursor do |cursor|
+        cursor = Wx::Cursor.new(cursor) if cursor.is_a?(Wx::StockCursor)
         wx_set_cursor.bind(self).call(cursor.is_a?(Wx::Cursor) ? Wx::CursorBundle.new(cursor) :  cursor)
       end
     end

data/lib/wx/core/helpcontrollerhelpprovider.rb

@@ -12,17 +12,25 @@
 require_relative './simplehelpprovider'
 
 class Wx::HelpControllerHelpProvider < Wx::SimpleHelpProvider
-  def initialize(help_controller)
+  def initialize(help_controller = nil)
     super()
     @hc = help_controller
   end
 
+  def get_help_controller
+    @hc
+  end
+
+  def set_help_controller(help_controller)
+    @hc = help_controller
+  end
+
   # Show help for +win+; if the help text for +win+ is a string with a
   # single integer only, treats that as a section id for help and shows
   # that, otherwise shows a popup (native-style on Windows) of the text.
   def show_help(win)
     help_text = get_help(win)
-    return false if help_text.empty?
+    return false if help_text.empty? || @hc.nil?
     if help_text =~ /\A\d+\z/
       @hc.display_context_popup(help_text.to_i)
     else

data/lib/wx/core/mbconv.rb

@@ -0,0 +1,11 @@
+# Copyright (c) 2023 M.J.N. Corino, The Netherlands
+#
+# This software is released under the MIT license.
+
+
+module Wx
+
+  ConvUTF8 = MBConvUTF8.new
+  ConvUTF7 = MBConvUTF7.new
+
+end

data/lib/wx/core/media_ctrl.rb

@@ -0,0 +1,31 @@
+# Copyright (c) 2023 M.J.N. Corino, The Netherlands
+#
+# This software is released under the MIT license.
+
+
+module Wx
+
+
+  class MediaCtrl < Wx::Control
+
+  if Wx::PLATFORM == 'WXMSW'
+  
+  wx_load = instance_method :load
+  wx_redefine_method :load do |*args|
+	uri_or_path = args.shift
+	if args.empty? && uri_or_path.is_a?(::URI) && uri_or_path.scheme == 'file'
+	  if uri_or_path.host.empty?
+		wx_load.bind(self).call("#{uri_or_path.path}")
+	  else
+		wx_load.bind(self).call("#{uri_or_path.host}:#{uri_or_path.path}")
+	  end
+	else
+	  wx_load.bind(self).call(uri_or_path, *args)
+	end
+  end
+
+  end
+
+  end
+
+end

data/lib/wx/core/top_level_window.rb

@@ -11,6 +11,13 @@ module Wx
       PersistentTLW.new(self)
     end
 
+    # fix missing method on some platforms/wxw versions
+    unless method_defined? :enable_full_screen_view
+      def enable_full_screen_view
+        false
+      end
+    end
+
   end
 
 end

data/lib/wx/core.rb

@@ -26,6 +26,12 @@ Wx::WXWIDGETS_VERSION = '%i.%i.%i' % [ Wx::WXWIDGETS_MAJOR_VERSION,
                                        Wx::WXWIDGETS_MINOR_VERSION,
                                        Wx::WXWIDGETS_RELEASE_NUMBER ]
 
+# except when in debug mode or when a user defined diagnostics level is defined
+# suppress all diagnostics from GTK
+unless Wx::DEBUG || ENV['WXSUPPRESS_GTK_DIAGNOSTICS'] || Wx::PLATFORM != 'WXGTK'
+  Wx::App.gtk_suppress_diagnostics
+end
+
 # Helper functions
 require 'wx/helpers'
 

data/lib/wx/doc/art_provider.rb

@@ -0,0 +1,17 @@
+# :stopdoc:
+# Copyright (c) 2023 M.J.N. Corino, The Netherlands
+#
+# This software is released under the MIT license.
+
+
+# This module provides and standardizes support for locating application art files.
+#
+# :startdoc:
+
+
+module Wx
+
+  ART_STOP = "wxART_STOP"
+  ART_REFRESH = "wxART_REFRESH"
+
+end

data/lib/wx/doc/context_help.rb

@@ -0,0 +1,42 @@
+# :stopdoc:
+# Copyright (c) 2023 M.J.N. Corino, The Netherlands
+#
+# This software is released under the MIT license.
+# :startdoc:
+
+
+module Wx
+
+  # This method changes the cursor to a query and puts the application into a 'context-sensitive help mode'.
+  #
+  # When the user left-clicks on a window within the specified window, a Wx::EVT_HELP event is sent to that control,
+  # and the application may respond to it by popping up some help.
+  # The method returns after the left-click.
+  #
+  # For example:
+  #
+  # ```ruby
+  #   Wx.context_help(myWindow)
+  # ```
+  #
+  # There are a couple of ways to invoke this behaviour implicitly:
+  #
+  # - Use the Wx::DIALOG_EX_CONTEXTHELP style for a dialog (WXMSW only). This will put a question mark in the titlebar,
+  #   and Windows will put the application into context-sensitive help mode automatically, without further programming.
+  # - Create a Wx::ContextHelpButton, whose predefined behaviour is to create a context help object. Normally you will
+  #   write your application so that this button is only added to a dialog for non-Windows platforms (use
+  #   Wx::DIALOG_EX_CONTEXTHELP on WXMSW).
+  #
+  # Note that on macOS, the cursor does not change when in context-sensitive help mode.
+  #
+  # @param [Wx::Window] window  the window which will be used to catch events; if nullptr, the top window will be used.
+  # @return [void]
+  def self.context_help(window = nil); end
+
+  # Convenience alias for {Wx.context_help} similarly named as the wxWidgets wxContextHelp class.
+  #
+  # @param [Wx::Window] window  the window which will be used to catch events; if nullptr, the top window will be used.
+  # @return [void]
+  def self.ContextHelp(window = nil); end
+
+end

data/lib/wx/doc/core.rb

@@ -8,11 +8,6 @@
 module Wx
 
   class << self
-    # Returns trace level (always 0 if #wxrb_debug returns false)
-    # In case #wxrb_debug returns true #wxrb_trace_level= is also defined)
-    # @return [Integer]
-    attr_reader :wrb_trace_level
-
     # Returns true if WXWIDGETS_VERSION >= ver
     # @param [String,Array(Integer)] ver version string or integer array (1-3)
     # @return [Boolean] true if WXWIDGETS_VERSION >= ver, false otherwise

data/lib/wx/doc/functions.rb

@@ -36,6 +36,16 @@ module Wx
   # @return [void]
   def self.log_info(fmt, *args, filename: nil, line: 0, func: nil, component: nil) end
 
+  # Log a Wx error informational message to the current Wx log output and abort (exit code 3)
+  # @param fmt  [String]  message (formatting) string
+  # @param args [Array<Object>] optional message arguments
+  # @param filename [String] optional file name for log info
+  # @param line [Integer] optional line number for log info
+  # @param func [String] optional function name for log info
+  # @param component [String] optional component name for log info
+  # @return [void]
+  def self.log_fatal_error(fmt, *args, filename: nil, line: 0, func: nil, component: nil) end
+
   # Log a Wx Informational message to the current Wx log output
   # @param fmt  [String]  message (formatting) string
   # @param args [Array<Object>] optional message arguments

data/lib/wx/doc/html/html_help_controller.rb

@@ -9,7 +9,7 @@ module Wx
 
   module HTML
 
-    class HelpController
+    class HtmlHelpController
 
       # Returns the latest frame size and position settings and whether a new frame is drawn with each invocation.
       # @return [Array(Wx::Frame,Wx::Size,Wx::Point,Boolean)] latest frame settings
@@ -17,6 +17,28 @@ module Wx
 
     end
 
+    # This module method uses Wx::HTML::HtmlHelpController to display help in a modal dialog and returns after
+    # the dialog has been closed.
+    #
+    # This is useful on platforms such as WXOSX where if you display help from a modal dialog, the help window must
+    # itself be a modal dialog.
+    #
+    # @param [Wx::Window] parent parent of the dialog.
+    # @param [String] help_file the HTML help file to show.
+    # @param [String] topic an optional topic. If this is empty, the help contents will be shown.
+    # @param [Integer] style is a combination of the flags described in the {Wx::HTML::HtmlHelpController} documentation.
+    # @return [void]
+    def self.html_modal_help(parent, help_file, topic = '', style = Wx::HTML::HF_DEFAULT_STYLE); end
+
+    # Convenience alias for {Wx::HTML.html_modal_help} similarly named as the wxWidgets wxHtmlModalHelp class.
+    #
+    # @param [Wx::Window] parent parent of the dialog.
+    # @param [String] help_file the HTML help file to show.
+    # @param [String] topic an optional topic. If this is empty, the help contents will be shown.
+    # @param [Integer] style is a combination of the flags described in the {Wx::HTML::HtmlHelpController} documentation.
+    # @return [void]
+    def self.HtmlModalHelp(parent, help_file, topic, style = Wx::HTML::HF_DEFAULT_STYLE); end
+
   end
 
 end

data/lib/wx/doc/mbconv.rb

@@ -0,0 +1,108 @@
+# :stopdoc:
+# Copyright (c) 2023 M.J.N. Corino, The Netherlands
+#
+# This software is released under the MIT license.
+# :startdoc:
+
+
+module Wx
+
+  # This class is the base class of a hierarchy of classes capable of converting text strings between multibyte
+  # (SBCS or DBCS) encodings and Unicode.
+  #
+  # This is an abstract base class which defines the operations implemented by all different conversion classes.
+  #
+  # @note Note that in wxRuby these classes only provide types without any operations as these are not required
+  #       as Ruby provides its own perfectly good encoding conversion methods. These types are therefor only required
+  #       to provide as argument to certain methods of the wrapped wxWidgets classes (see for example {Wx::WEB::WebViewHandlerResponse}).
+  class MBConv
+    protected def initialize; end
+  end
+
+  # This class converts between any character set supported by the system and Unicode.
+  class CSConv < MBConv
+
+  end
+
+  # This class implements a Unicode to/from multibyte converter capable of automatically recognizing the encoding of the
+  # multibyte text on input.
+  #
+  # The logic used is very simple: the class uses the BOM (byte order mark) if it's present and tries to interpret the
+  # input as UTF-8 otherwise. If this fails, the input is interpreted as being in the default multibyte encoding which
+  # can be specified in the constructor of a {Wx::ConvAuto} instance and, in turn, defaults to a fallback encoding if not
+  # explicitly given.
+  #
+  # For the conversion from Unicode to multibyte, the same encoding as was previously used for multibyte to Unicode conversion is reused. If there had been no previous multibyte to Unicode conversion, UTF-8 is used by default. Notice that once the multibyte encoding is automatically detected, it doesn't change any more, i.e. it is entirely determined by the first use of wxConvAuto object in the multibyte-to-Unicode direction. However creating a copy of wxConvAuto object, either via the usual copy constructor or assignment operator, or using wxMBConv::Clone(), resets the automatically detected encoding so that the new copy will try to detect the encoding of the input on first use.
+  #
+  # This class is used by default in wxWidgets classes and functions reading text from files such as wxFile, wxFFile, wxTextFile, wxFileConfig and various stream classes so the encoding set with its SetFallbackEncoding() method will affect how these classes treat input files. In particular, use this method to change the fall-back multibyte encoding used to interpret the contents of the files whose contents isn't valid UTF-8 or to disallow it completely.
+  class ConvAuto < MBConv
+
+    # Constructs a new Wx::ConvAuto instance.
+    #
+    # The object will try to detect the input of the given multibyte text automatically but if the automatic detection
+    # of Unicode encodings fails, the fall-back encoding enc will be used to interpret it as multibyte text.
+    #
+    # The default value of enc, {Wx::FONTENCODING_DEFAULT}, means that the global default value (which can be set using
+    # {Wx::ConvAuto#set_fallback_encoding}) should be used. As with that method, passing Wx::FONTENCODING_MAX inhibits
+    # using this encoding completely so the input multibyte text will always be interpreted as UTF-8 in the absence of
+    # BOM and the conversion will fail if the input doesn't form valid UTF-8 sequence.
+    #
+    # Another special value is {Wx::FONTENCODING_SYSTEM} which means to use the encoding currently used on the user system,
+    # i.e. the encoding returned by {Wx::Locale#get_system_encoding}. Any other encoding will be used as is, e.g. passing
+    # {Wx::FONTENCODING_ISO8859_1} ensures that non-UTF-8 input will be treated as latin1.
+    # @param [Wx::FontEncoding] enc
+    def initialize(enc=Wx::FONTENCODING_DEFAULT); end
+
+    # Disable the use of the fallback encoding: if the input doesn't have a BOM and is not valid UTF-8, the conversion
+    # will fail.
+    def self.disable_fallback_encoding; end
+
+    # Returns the encoding used by default by {Wx::ConvAuto} if no other encoding is explicitly specified in constructor.
+    #
+    # By default, returns {Wx::FONTENCODING_ISO8859_1} but can be changed using #set_fallback_encoding.
+    # @return [Wx::FontEncoding]
+    def self.get_fallback_encoding; end
+
+    # Changes the encoding used by default by {Wx::ConvAuto} if no other encoding is explicitly specified in constructor.
+    #
+    # The default value, which can be retrieved using #get_fallback_encoding, is {Wx::FONTENCODING_ISO8859_1}.
+    #
+    # Special values of {Wx::FONTENCODING_SYSTEM} or {Wx::FONTENCODING_MAX} can be used for the enc parameter to use
+    # the encoding of the current user locale as fall back or not use any encoding for fall back at all, respectively
+    # (just as with the similar constructor parameter). However, {Wx::FONTENCODING_DEFAULT} can't be used here.
+    # @param [Wx::FontEncoding] enc
+    def self.set_fallback_encoding(enc); end
+  end
+
+  # This class is used to convert between multibyte encodings and UTF-16 Unicode encoding (also known as UCS-2).
+  #
+  # Unlike UTF-8 encoding, UTF-16 uses words and not bytes and hence depends on the byte ordering: big or little endian.
+  # Hence this class is provided in a little endian version and a big endian version. {Wx::MBConvUTF16} always provides
+  # the implementation native to the current platform (e.g. LE under Windows and BE under Mac).
+  class MBConvUTF16 < MBConv
+    def initialize; end
+  end
+
+  #This class is used to convert between multibyte encodings and UTF-32 Unicode encoding (also known as UCS-4).
+  #
+  # Unlike UTF-8 encoding, UTF-32 uses (double) words and not bytes and hence depends on the byte ordering: big or
+  # little endian. Hence this class is provided in in a little endian version and a big endian version. {Wx::MBConvUTF32}
+  # always provides the implementation native to the current platform (e.g. LE under Windows and BE under Mac).
+  class MBConvUTF32 < MBConv
+    def initialize; end
+  end
+
+  # This class converts between the UTF-7 encoding and Unicode.
+  #
+  # Notice that, unlike all the other conversion objects, this converter is stateful, and therefor <b>not</b> thread-safe.
+  # It has one predefined instance, Wx::ConvUTF7.
+  class MBConvUTF7 < MBConv
+    def initialize; end
+  end
+
+  # This class converts between the UTF-8 encoding and Unicode.
+  # It has one predefined instance, Wx::ConvUTF8.
+  class MBConvUTF8 < MBConv
+    def initialize; end
+  end
+end