wxruby3 0.9.7 → 1.0.0

data/rakelib/lib/config/pkgman/macosx.rb

@@ -18,7 +18,7 @@ module WXRuby3
 
           def install(pkgs)
             # do we need to install anything?
-            if !pkgs.empty?
+            unless pkgs.empty?
               # can we install XCode commandline tools?
               unless no_autoinstall? || !pkgs.include?('xcode') || has_sudo? || is_root?
                 STDERR.puts 'ERROR: Cannot check for or install required packages. Please install sudo or run as root and try again.'
@@ -50,18 +50,20 @@ module WXRuby3
 
           private
 
+          def pkgman
+            @pkgman ||= WXRuby3.config.sysinfo.os.pkgman
+          end
+
           def do_install(pkgs)
             rc = true
             # first see if we need to install XCode commandline tools
             if pkgs.include?('xcode')
               pkgs.delete('xcode')
-              rc = run('xcode-select --install')
+              rc = auth_run('xcode-select --install')
             end
-            # now check if we need any other packages (which need Homebrew or MacPorts)
+            # now check if we need any other packages
             if rc && !pkgs.empty?
-              # Has Ruby been installed through MacPorts?
-              if has_macports? &&
-                    (ruby_info = expand('port -q installed installed').strip.split("\n").find { |ln| ln.strip =~ /\Aruby\d+\s/ })
+              if pkgman.macports?
 
                 # this is really crap; with MacPorts we need to install swig-ruby instead of simply swig
                 # which for whatever nonsensical reason will pull in another (older) Ruby version (probably 2.3 or such)
@@ -70,59 +72,15 @@ module WXRuby3
                   pkgs.delete('swig')
                   pkgs << 'swig-ruby'
                 end
-                # in case MacPorts was installed with root privileges this install would also have to be run
-                # with root privileges (otherwise it would fail early on with access problems) so we can
-                # just run without sudo as we either have root privileges for root-installed MacPorts or
-                # we're running without root privileges for user-installed MacPorts
-                pkgs.each { |pkg| rc &&= sh("port install #{pkg}") }
-
-              # or are we running without root privileges and have Homebrew installed?
-              # (Ruby may be installed using Homebrew itself or using a Ruby version manager like RVM)
-              elsif !is_root? && has_homebrew?
 
-                pkgs.each { |pkg| rc &&= sh("brew install #{pkg}") }
-
-              # or do we have MacPorts (running either privileged or not) and
-              # a Ruby installed using a Ruby version manager.
-              elsif has_macports?
-
-                # same crap as above
-                if pkgs.include?('swig')
-                  pkgs.delete('swig')
-                  pkgs << 'swig-ruby'
-                end
-                # in case MacPorts was installed with root privileges this install would also have to be run
-                # with root privileges (otherwise it would fail early on with access problems) so we can
-                # just run without sudo as we either have root privileges for root-installed MacPorts or
-                # we're running without root privileges for user-installed MacPorts
-                pkgs.each { |pkg| rc &&= sh("port install #{pkg}") }
-
-              else
-                if has_homebrew? || is_root?
-                  $stderr.puts <<~__ERROR_TXT
-                    ERROR: Unsupported Ruby installation. wxRuby3 can only be installed for Ruby with root privileges
-                           in case Ruby was installed with MacPorts. Homebrew should not be run with root privileges.
-                      
-                    Re-install a supported Ruby setup and try again.
-                    __ERROR_TXT
-                else
-                  $stderr.puts <<~__ERROR_TXT
-                    ERROR: Unsupported Ruby installation. wxRuby3 requires either a MacPorts installed Ruby version 
-                           or a non-privileged Ruby installation and have Homebrew installed.
-                      
-                    Install either Homebrew or MacPorts and try again.
-                    __ERROR_TXT
-                end
-                exit(1)
               end
+
+              # actually install packages
+              pkgs.each { |pkg| rc &&= run(pkgman.make_install_command(pkg)); break unless rc }
             end
             rc
           end
 
-          def builds_wxwidgets?
-            Config.get_config('with-wxwin') && Config.get_cfg_string('wxwin').empty?
-          end
-
           def no_autoinstall?
             Config.get_config('autoinstall') == false
           end
@@ -132,46 +90,27 @@ module WXRuby3
           end
 
           def has_sudo?
-            system('command -v sudo > /dev/null')
+            WXRuby3.config.sysinfo.os.has_sudo?
           end
 
           def is_root?
-            if @is_root.nil?
-              @is_root = (`id -u 2>/dev/null`.chomp == '0')
-            end
-            @is_root
-          end
-
-          def has_macports?
-            if @has_macports.nil?
-              @has_macports = system('command -v port>/dev/null')
-            end
+            WXRuby3.config.sysinfo.os.is_root?
           end
 
-          def has_homebrew?
-            if @has_homebrew.nil?
-              @has_homebrew = system('command -v brew>/dev/null')
-            end
-          end
-
-          def run(cmd)
+          def auth_run(cmd)
             $stdout.print "Running #{cmd}..."
             rc = WXRuby3.config.sh("#{is_root? ? '' : 'sudo '}#{cmd}")
-            $stderr.puts (rc ? 'done!' : 'FAILED!')
+            $stderr.puts(rc ? 'done!' : 'FAILED!')
             rc
           end
 
-          def sh(*cmd, title: nil)
+          def run(*cmd, title: nil)
             $stdout.print(title ? title : "Running #{cmd}...")
             rc = WXRuby3.config.sh(*cmd)
-            $stderr.puts (rc ? 'done!' : 'FAILED!')
+            $stderr.puts(rc ? 'done!' : 'FAILED!')
             rc
           end
 
-          def expand(cmd)
-            WXRuby3.config.expand(cmd)
-          end
-
         end
 
       end

data/rakelib/lib/config/unixish.rb

@@ -66,6 +66,12 @@ module WXRuby3
       def get_rpath_origin
         "$ORIGIN"
       end
+      protected :get_rpath_origin
+
+      # add deployment lookup paths for wxruby shared libraries
+      def update_shlib_loadpaths(shlib)
+        WXRuby3.config.patch_rpath(shlib, WXRuby3.config.get_rpath_origin, "#{WXRuby3.config.get_rpath_origin}/../ext")
+      end
 
       def expand(cmd)
         STDERR.puts "> sh: #{cmd}" if verbose?
@@ -74,6 +80,10 @@ module WXRuby3
         s
       end
 
+      def download_file(url, dest)
+        sh("curl -L #{url} --output #{dest}")
+      end
+
       private
 
       def wx_checkout
@@ -82,11 +92,10 @@ module WXRuby3
         chdir(ext_path) do
           if (rc = sh("#{get_cfg_string('git')} clone https://github.com/wxWidgets/wxWidgets.git"))
             chdir('wxWidgets') do
-              tag = if @wx_version
-                      "v#{@wx_version}"
-                    else
-                      expand("#{get_cfg_string('git')} tag").split("\n").select { |t| (/\Av3\.(\d+)/ =~ t) && $1.to_i >= 2  }.max
-                    end
+              tag = wx_gitref ||
+                expand("#{get_cfg_string('git')} tag").split("\n").select do |t|
+                  (/\Av(\d+)\.(\d+)\.\d+\Z/ =~ t) && (($1.to_i == 3 && $2.to_i >= 2) || $1.to_i > 3)
+                end.max
               # checkout the version we are building against
               rc = sh("#{get_cfg_string('git')} checkout #{tag}")
             end
@@ -101,7 +110,7 @@ module WXRuby3
       end
 
       def wx_configure
-        bash('./configure --prefix=`pwd`/install --disable-tests --without-subdirs --disable-debug_info')
+        bash('./configure --prefix=`pwd`/install --disable-tests --without-subdirs --without-regex --disable-debug_info')
       end
 
       def wx_make
@@ -210,8 +219,8 @@ module WXRuby3
           # add ruby defined shared ruby lib(s); not any other flags
           @ruby_libs.concat RB_CONFIG['LIBRUBYARG_SHARED'].split(' ').select { |s| s.start_with?('-l')}
 
-          # maintain minimum compatibility with ABI 3.0.0
-          @wx_abi_version = [ @wx_version, "3.0.0" ].min
+          # maintain minimum compatibility with ABI 3.0.1
+          @wx_abi_version = [ @wx_version, "3.0.1" ].min
           @wx_cppflags << "-DwxABI_VERSION=%s" % @wx_abi_version.tr(".", "0")
         end
       end

data/rakelib/lib/config/{netbsd.rb → unknown.rb}

@@ -3,7 +3,8 @@
 # This software is released under the MIT license.
 
 ###
-# wxRuby3 buildtools configuration
+# wxRuby3 buildtools configuration fallback
 ###
 
-raise "NETBSD platform is unsupported as yet."
+$stderr.puts 'ERROR: Unsupported Ruby platform!'
+exit(1)

data/rakelib/lib/config.rb

@@ -11,6 +11,7 @@ require 'fileutils'
 require 'json'
 require 'open3'
 require 'monitor'
+require 'plat4m'
 
 module FileUtils
   # add convenience methods
@@ -67,7 +68,8 @@ module WXRuby3
     'sodir' => '$siterubyverarch',
   }
 
-  CFG_KEYS.concat(%w{wxwin wxxml wxwininstdir with-wxwin with-debug swig doxygen})
+  CFG_KEYS.concat(%w{wxwin wxxml wxwininstdir with-wxwin with-debug swig doxygen git})
+  WXW_SYS_KEY = 'with-system-wxwin'
   CONFIG.merge!({
                   'wxwin' => ENV['WXWIN'] || '',
                   'wxxml' => ENV['WXXML'] || '',
@@ -280,7 +282,7 @@ module WXRuby3
           end
           begin
             # setup ENV for child execution
-            ENV.merge!(Config.instance.exec_env)
+            ENV.update(Config.instance.exec_env)
             output = `#{cmd.join(' ')}`
           ensure
             # restore ENV
@@ -311,7 +313,7 @@ module WXRuby3
     private :make_ruby_cmd
 
     def execute(*cmd)
-      do_run(*cmd.flatten)
+      sh(exec_env.merge({'RUBYLIB'=>rb_lib_path}), cmd.flatten.join(' '), fail_on_error: true)
     end
 
     def run(*cmd, capture: nil, verbose: true)
@@ -350,7 +352,7 @@ module WXRuby3
 
     def test(*tests, **options)
       errors = 0
-      excludes = (ENV['WXRUBY_TEST_EXCLUDE'] || '').split(';')
+      excludes = (ENV['WXRUBY_TEST_EXCLUDE'] || '').split(':')
       tests = Dir.glob(File.join(Config.instance.test_dir, '*.rb')) if tests.empty?
       tests.each do |test|
         unless excludes.include?(File.basename(test, '.*'))
@@ -381,6 +383,10 @@ module WXRuby3
       []
     end
 
+    def download_file(_url, _dest)
+      raise NoMethodError
+    end
+
     def install_prerequisites
       pkg_deps = check_tool_pkgs
       if get_config('autoinstall') == false
@@ -443,16 +449,22 @@ module WXRuby3
     def get_rpath_origin
       ''
     end
+    protected :get_rpath_origin
 
-    def check_rpath_patch
+    def patch_rpath(_shlib, *)
       true
     end
+    protected :patch_rpath
 
-    def patch_rpath(_shlib, *)
+    def update_shlib_loadpaths(_shlib)
       true
     end
 
-    def update_shlib_loadpaths(_shlib, _deplibs)
+    def update_shlib_ruby_libpath(_shlib)
+      true
+    end
+
+    def update_shlib_wxwin_libpaths(_shlib, _deplibs)
       true
     end
 
@@ -494,15 +506,23 @@ module WXRuby3
       end
 
       def save
+        cfg = WXRuby3::CONFIG.dup
+        wxw_system = !!cfg.delete(WXW_SYS_KEY)
+        cfg['wxwin'] = '@system' if wxw_system
         File.open(build_cfg, 'w') do |f|
-          f << JSON.pretty_generate(WXRuby3::CONFIG)
+          f << JSON.pretty_generate(cfg)
         end
       end
 
       def load
         if File.file?(build_cfg)
           File.open(build_cfg, 'r') do |f|
-            WXRuby3::CONFIG.merge!(JSON.load(f.read))
+            cfg = JSON.load(f.read)
+            if cfg['wxwin'] == '@system'
+              cfg[WXW_SYS_KEY] = true
+              cfg.delete('wxwin')
+            end
+            WXRuby3::CONFIG.merge!(cfg)
           end
         end
       end
@@ -515,10 +535,8 @@ module WXRuby3
         case RUBY_PLATFORM
         when /mingw/
           :mingw
-        when /cygwin/
-          :cygwin
-        when /netbsd/
-          :netbsd
+        when /freebsd/
+          :freebsd
         when /darwin/
           :macosx
         when /linux/
@@ -538,15 +556,26 @@ module WXRuby3
           def initialize
             @ruby_exe = RB_CONFIG["ruby_install_name"]
 
-            @extmk = /extmk\.rb/ =~ $0
-            @platform = Config.platform
-            require File.join(File.dirname(__FILE__), 'config', @platform.to_s)
+            @sysinfo = Plat4m.current rescue nil
+            @platform = if @sysinfo
+                          case @sysinfo.os.id
+                          when :darwin
+                            :macosx
+                          when :windows
+                            RUBY_PLATFORM =~ /mingw/ ? :mingw : :unknown
+                          else
+                            @sysinfo.os.id
+                          end
+                        else
+                          :unknown
+                        end
+            require_relative File.join('config', @platform.to_s)
             self.class.include(WXRuby3::Config::Platform)
 
             init # initialize settings
           end
 
-          attr_reader :ruby_exe, :extmk, :platform, :helper_modules, :helper_inits, :include_modules, :verbosity
+          attr_reader :ruby_exe, :sysinfo, :platform, :helper_modules, :helper_inits, :include_modules, :verbosity
           attr_reader :release_build, :debug_build, :verbose_debug, :no_deprecate
           attr_reader :ruby_cppflags, :ruby_ldflags, :ruby_libs, :extra_cflags, :extra_cppflags, :extra_ldflags,
                       :extra_libs, :cpp_out_flag, :link_output_flag, :obj_ext, :dll_ext,
@@ -593,11 +622,6 @@ module WXRuby3
 
             # Extra swig helper files to be built
             @helper_modules = %w|RubyStockObjects|
-              # if macosx?
-              #                   %w|RubyStockObjects Mac|
-              #                 else
-              #                   %w|RubyStockObjects|
-              #                 end
             # helper to initialize on startup (stock objects can only be initialized after App creation)
             @helper_inits = @helper_modules - %w|RubyStockObjects|
 
@@ -640,7 +664,7 @@ module WXRuby3
             @obj_ext          = RB_CONFIG["OBJEXT"]
             @dll_ext          = RB_CONFIG['DLEXT']
 
-            # Exclude certian classes from being built, even if they are present
+            # Exclude certain classes from being built, even if they are present
             # in the configuration of wxWidgets.
             if ENV['WXRUBY_EXCLUDED']
               ENV['WXRUBY_EXCLUDED'].split(",").each { |classname| exclude_module(classname) }
@@ -696,6 +720,10 @@ module WXRuby3
             get_config('with-wxwin')
           end
 
+          def with_wxhead?
+            get_config('with-wxhead')
+          end
+
           def wx_version
             @wx_version || ''
           end
@@ -704,16 +732,12 @@ module WXRuby3
             @wx_abi_version || ''
           end
 
-          def cygwin?
-            @platform == :cygwin
-          end
-
           def mingw?
             @platform == :mingw
           end
 
-          def netbsd?
-            @platform == :netbsd
+          def freebsd?
+            @platform == :freebsd
           end
 
           def macosx?
@@ -725,7 +749,7 @@ module WXRuby3
           end
 
           def windows?
-            mingw? || cygwin?
+            mingw?
           end
 
           def ldflags(_target)
@@ -740,6 +764,17 @@ module WXRuby3
             [ rake_deps_path, src_path, src_gen_path, obj_path, classes_path, common_path, interface_path ]
           end
 
+          def wx_gitref
+            if @wx_version
+              "v#{@wx_version}"
+            elsif get_config('with-wxhead')
+              'master'
+            else
+              nil
+            end
+          end
+          private :wx_gitref
+
           def do_bootstrap
             install_prerequisites
             # do we have a local wxWidgets tree already?
@@ -812,9 +847,15 @@ module WXRuby3
             features = {}
 
             if is_configured? && wxwidgets_setup_h
-              File.read(wxwidgets_setup_h).scan(/^\s*#define\s+(wx\w+|__\w+__)\s+([01])/) do | define |
-                feat_val = $2.to_i.zero? ? false : true
-                feat_id = $1.sub(/\Awx/i, '').gsub(/\A__|__\Z/, '')
+              File.read(wxwidgets_setup_h).scan(/^\s*#define\s+(wx\w+|__\w+__)\s+([01]|wx\w+)/) do | define |
+                val_str = $2
+                feat_str = $1
+                if val_str.start_with?('wx')
+                  feat_val = !!features[val_str.sub(/\Awx/i, '')]
+                else
+                  feat_val = val_str.to_i.zero? ? false : true
+                end
+                feat_id = feat_str.sub(/\Awx/i, '').gsub(/\A__|__\Z/, '')
                 features[feat_id] = feat_val
               end
               # make sure correct platform defines are included as well which will not be the case always

data/rakelib/lib/core/include/enum.inc

@@ -177,6 +177,7 @@ static VALUE wx_Enum_sc_create_enum_class(int argc, VALUE *argv, VALUE self)
   ID id_to_i = rb_intern("to_i");
   ID id_const_set = rb_intern("const_set");
   VALUE enum_klass = rb_funcall(rb_cClass, id_new, 1, cWxEnum, 0);
+  VALUE enum_singleton_klass = rb_funcall(enum_klass, rb_intern("singleton_class"), 0, 0);
   VALUE enum_values = rb_funcall(argv[1], rb_intern("keys"), 0, 0);
   for (int i=0; i<RARRAY_LEN(enum_values) ;++i)
   {
@@ -184,6 +185,8 @@ static VALUE wx_Enum_sc_create_enum_class(int argc, VALUE *argv, VALUE self)
     VALUE enum_value_num = rb_funcall(rb_hash_aref(argv[1], enum_value_name), id_to_i, 0, 0);
     VALUE enum_value = rb_funcall(enum_klass, id_new, 1, enum_value_num, 0);
     rb_funcall(enum_klass, id_const_set, 2, enum_value_name, enum_value, 0);
+    rb_hash_aset(rb_iv_get(enum_singleton_klass, __iv_enum_klass_values), enum_value_num, enum_value);
+    rb_hash_aset(rb_iv_get(enum_singleton_klass, __iv_enum_klass_values_by_name), rb_to_symbol(enum_value_name), enum_value);
   }
   rb_hash_aset(rb_iv_get(cEnum_Singleton, __iv_Enum_sc_enums), enum_name, enum_klass);
   return enum_klass;
@@ -230,10 +233,31 @@ static VALUE wx_Enum_sc_get_enum_value(int argc, VALUE *argv, VALUE self)
   return rb_hash_aref(rb_iv_get(enum_singleton_klass, __iv_enum_klass_values_by_name), rb_to_symbol(argv[0]));
 }
 
+static VALUE wx_Enum_sc_get_enum_values(VALUE self)
+{
+  VALUE enum_singleton_klass = rb_funcall(self, rb_intern("singleton_class"), 0, 0);
+  return rb_iv_get(enum_singleton_klass, __iv_enum_klass_values);
+}
+
+static VALUE wx_Enum_sc_get_enum_values_by_name(VALUE self)
+{
+  VALUE enum_singleton_klass = rb_funcall(self, rb_intern("singleton_class"), 0, 0);
+  return rb_iv_get(enum_singleton_klass, __iv_enum_klass_values_by_name);
+}
+
+static VALUE wx_Enum_sc_get_enum_names_by_value(VALUE self)
+{
+  VALUE enum_singleton_klass = rb_funcall(self, rb_intern("singleton_class"), 0, 0);
+  return rb_funcall(rb_iv_get(enum_singleton_klass, __iv_enum_klass_values_by_name), rb_intern("invert"), 0);
+}
+
 WXRB_EXPORT_FLAG VALUE wxRuby_CreateEnumClass(const char* enum_class_name_cstr)
 {
   VALUE enum_klass = rb_funcall(rb_cClass, rb_intern("new"), 1, cWxEnum, 0);
   rb_define_singleton_method(enum_klass, "[]", VALUEFUNC(wx_Enum_sc_get_enum_value), -1);
+  rb_define_singleton_method(enum_klass, "values", VALUEFUNC(wx_Enum_sc_get_enum_values), 0);
+  rb_define_singleton_method(enum_klass, "values_by_name", VALUEFUNC(wx_Enum_sc_get_enum_values_by_name), 0);
+  rb_define_singleton_method(enum_klass, "names_by_value", VALUEFUNC(wx_Enum_sc_get_enum_names_by_value), 0);
   VALUE enum_singleton_klass = rb_funcall(enum_klass, rb_intern("singleton_class"), 0, 0);
   rb_iv_set(enum_singleton_klass, __iv_enum_klass_values, rb_hash_new());
   rb_iv_set(enum_singleton_klass, __iv_enum_klass_values_by_name, rb_hash_new());
@@ -266,7 +290,13 @@ WXRB_EXPORT_FLAG VALUE wxRuby_GetEnumValueObject(const char* enum_wx_class_name_
     VALUE enum_klass = rb_hash_aref(enum_hash, ID2SYM(rb_intern(enum_class_name)));
     VALUE enum_singleton_klass = rb_funcall(enum_klass, rb_intern("singleton_class"), 0, 0);
     VALUE enum_values_hash = rb_iv_get(enum_singleton_klass, __iv_enum_klass_values);
-    return rb_hash_aref(enum_values_hash, INT2NUM(enum_val));
+    VALUE rc = rb_hash_aref(enum_values_hash, INT2NUM(enum_val));
+    if (NIL_P(rc))
+    {
+      VALUE args[1] = { INT2NUM(enum_val) };
+      rc = rb_class_new_instance(1, args, enum_klass);
+    }
+    return rc;
   }
   return Qnil;
 }

data/rakelib/lib/director/affine_matrix.rb

@@ -0,0 +1,51 @@
+# Copyright (c) 2023 M.J.N. Corino, The Netherlands
+#
+# This software is released under the MIT license.
+
+###
+# wxRuby3 wxWidgets interface director
+###
+
+module WXRuby3
+
+  class Director
+
+    class AffineMatrix2D < Director
+
+      def setup
+        spec.items.unshift('wxAffineMatrix2DBase') << 'wxMatrix2D'
+
+        spec.make_abstract 'wxAffineMatrix2DBase'
+        spec.disable_proxies
+
+        spec.map_apply 'int * OUTPUT' => ['wxDouble *']
+        spec.map 'wxPoint2DDouble *' => 'Wx::Point2DDouble' do
+          map_in ignore: true, temp: 'wxPoint2DDouble tmp', code: '$1 = &tmp;'
+
+          map_argout code: <<~__CODE
+            $result = SWIG_Ruby_AppendOutput($result, SWIG_NewPointerObj(new wxPoint2DDouble(tmp$argnum), SWIGTYPE_p_wxPoint2DDouble, SWIG_POINTER_OWN));
+            __CODE
+        end
+        spec.map 'wxMatrix2D *' => 'Wx::Matrix2D' do
+          map_in ignore: true, temp: 'wxMatrix2D tmp', code: '$1 = &tmp;'
+
+          map_argout code: <<~__CODE
+            $result = SWIG_Ruby_AppendOutput($result, SWIG_NewPointerObj(new wxMatrix2D(tmp$argnum), SWIGTYPE_p_wxPoint2DDouble, SWIG_POINTER_OWN));
+            __CODE
+        end
+
+        spec.ignore 'wxAffineMatrix2D::Mirror',
+                    'wxAffineMatrix2D::TransformPoint',
+                    'wxAffineMatrix2D::TransformDistance',
+                    'wxAffineMatrix2D::IsEqual'
+
+        spec.regard 'wxMatrix2D::m_11', 'wxMatrix2D::m_12',
+                    'wxMatrix2D::m_21', 'wxMatrix2D::m_22'
+
+      end
+
+    end
+
+  end
+
+end

data/rakelib/lib/director/app.rb

@@ -87,31 +87,47 @@ module WXRuby3
           }
           __HEREDOC
         if Config.platform == :macosx
-          # add accessor methods for the standard OSX menu items
+          # add static accessor methods for the standard OSX menu items
           spec.add_extend_code 'wxApp', <<~__HEREDOC
-            void set_mac_about_menu_itemid(long menu_itemid)
+            static void set_mac_about_menu_itemid(long menu_itemid)
             {
-              $self->s_macAboutMenuItemId = menu_itemid;
+              wxApp::s_macAboutMenuItemId = menu_itemid;
             }
-            long get_mac_about_menu_itemid(long menu_itemid)
+            static long get_mac_about_menu_itemid(long menu_itemid)
             {
-              return $self->s_macAboutMenuItemId;
+              return wxApp::s_macAboutMenuItemId;
             }
-            void set_mac_preferences_menu_itemid(long menu_itemid)
+            static void set_mac_preferences_menu_itemid(long menu_itemid)
             {
-              $self->s_macPreferencesMenuItemId = menu_itemid;
+              wxApp::s_macPreferencesMenuItemId = menu_itemid;
             }
-            long get_mac_preferences_menu_itemid(long menu_itemid)
+            static long get_mac_preferences_menu_itemid(long menu_itemid)
             {
-              return $self->s_macPreferencesMenuItemId;
+              return wxApp::s_macPreferencesMenuItemId;
             }
-            void set_mac_exit_menu_itemid(long menu_itemid)
+            static void set_mac_exit_menu_itemid(long menu_itemid)
             {
-              $self->s_macExitMenuItemId = menu_itemid;
+              wxApp::s_macExitMenuItemId = menu_itemid;
             }
-            long get_mac_exit_menu_itemid(long menu_itemid)
+            static long get_mac_exit_menu_itemid(long menu_itemid)
             {
-              return $self->s_macExitMenuItemId;
+              return wxApp::s_macExitMenuItemId;
+            }
+            static void set_mac_help_menu_title(const wxString& title)
+            {
+              wxApp::s_macHelpMenuTitleName = title;
+            }
+            static const wxString& get_mac_help_menu_title()
+            {
+              return wxApp::s_macHelpMenuTitleName;
+            }
+            static void set_mac_window_menu_title(const wxString& title)
+            {
+              wxApp::s_macWindowMenuTitleName = title;
+            }
+            static const wxString& get_mac_window_menu_title()
+            {
+              return wxApp::s_macWindowMenuTitleName;
             }
             __HEREDOC
         end

data/rakelib/lib/director/art_provider.rb

@@ -28,6 +28,10 @@ module WXRuby3
           // ArtId and ArtClient are basically just strings ...
           typedef wxString wxArtID;
           typedef wxString wxArtClient;
+
+          // Missing from docs
+          %constant const char* wxART_STOP = wxART_STOP;
+          %constant const char* wxART_REFRESH = wxART_REFRESH;
           __HEREDOC
         spec.map *%w[wxArtID wxArtClient], as: 'String', swig: false do
           map_in

data/rakelib/lib/director/aui_manager.rb

@@ -53,7 +53,7 @@ module WXRuby3
               m_actionWindow = NULL;
               m_hoverButton = NULL;
               m_art = new wxAuiDefaultDockArt;
-              m_hintWnd = NULL;
+              #{Config.instance.wx_version < '3.3.0' ? 'm_hintWnd = NULL;' : ''}
               m_flags = wxAUI_MGR_DEFAULT;
               m_hasMaximized = false;
               m_dockConstraintX = 0.3;

data/rakelib/lib/director/cursor.rb

@@ -20,8 +20,12 @@ module WXRuby3
                          'wxCursor::wxCursor(const wxImage &)',
                          'wxCursor::wxCursor(const char *const *)',
                          'wxCursor::wxCursor(const wxCursor &)'
-        spec.ignore 'wxCursor::wxCursor(const char[],int,int,int,int,const char[])',
-                    'wxCursor::wxCursor(const char *const *)'
+        spec.ignore 'wxCursor::wxCursor(const char *const *)'
+        if Config.instance.wx_version >= '3.3.0'
+          spec.ignore 'wxCursor::wxCursor(const char[],int,int,int,int,const char[], const wxColour*, const wxColour*)'
+        else
+          spec.ignore 'wxCursor::wxCursor(const char[],int,int,int,int,const char[])'
+        end
         # ignore stock object (see RubyStockObjects.i)
         spec.ignore %w[wxSTANDARD_CURSOR wxHOURGLASS_CURSOR wxCROSS_CURSOR]
         super