wxruby3 1.7.0 → 1.8.1

data/rakelib/lib/director/variant.rb

@@ -388,25 +388,22 @@ module WXRuby3
           WXRUBY_TRACE_GUARD(WxRubyTraceGCTrackVariant, "GC_TRACK_VARIANT")
 
           class WXRBValueVariantData;
-          // Mapping of WXRBValueVariantData* to Ruby VALUE
-          WX_DECLARE_VOIDPTR_HASH_MAP(VALUE,
-                                      WXRBVariantDataToRbValueHash);
-          static WXRBVariantDataToRbValueHash Variant_Value_Map;
 
-          static void GC_mark_RbValueVariants()
+          static const std::string WXRUBY_VARIANT_DATA = { "WXRUBY_VARIANT_DATA" };
+
+          static void GC_mark_RbValueVariants(const TGCTrackingValueMap& values)
           {
             WXRUBY_TRACE_IF(WxRubyTraceGCMarkVariant, 2)
               WXRUBY_TRACE("> GC_mark_RbValueVariants")
             WXRUBY_TRACE_END
 
-            WXRBVariantDataToRbValueHash::iterator it;
-            for( it = Variant_Value_Map.begin(); it != Variant_Value_Map.end(); ++it )
+            for(const auto& ti : values)
             {
-              VALUE obj = it->second;
+              VALUE obj = ti.second;
 
               WXRUBY_TRACE_IF(WxRubyTraceGCMarkVariant, 2)
                 WXRUBY_TRACE_WITH(void *c_ptr = (TYPE(obj) == T_DATA ? DATA_PTR(obj) : 0))
-                WXRUBY_TRACE("| GC_mark_RbValueVariants : " << it->first << "|" << (void*)c_ptr)
+                WXRUBY_TRACE("| GC_mark_RbValueVariants : " << ti.first << "|" << (void*)c_ptr)
               WXRUBY_TRACE_END
 
               rb_gc_mark(obj);
@@ -419,12 +416,20 @@ module WXRuby3
 
           static void wxRuby_RegisterValueVariantData(void* ptr, VALUE rbval)
           {
+            static bool is_marker_registered = false;
+
             WXRUBY_TRACE_IF(WxRubyTraceGCTrackVariant, 2)
               WXRUBY_TRACE_WITH(void *c_ptr = (TYPE(rbval) == T_DATA ? DATA_PTR(rbval) : 0))
               WXRUBY_TRACE("> wxRuby_RegisterValueVariantData : " << ptr << "|" << (void*)c_ptr)
             WXRUBY_TRACE_END
 
-            Variant_Value_Map[ptr] = rbval;
+            if (!is_marker_registered)
+            {
+              wxRuby_RegisterTrackingCategory(WXRUBY_VARIANT_DATA, GC_mark_RbValueVariants, true);
+              is_marker_registered = true;
+            }
+
+            wxRuby_RegisterCategoryValue(WXRUBY_VARIANT_DATA, ptr, rbval);
 
             WXRUBY_TRACE_IF(WxRubyTraceGCMarkVariant, 2)
               WXRUBY_TRACE("< wxRuby_RegisterValueVariantData")
@@ -437,7 +442,7 @@ module WXRuby3
               WXRUBY_TRACE("> wxRuby_UnregisterValueVariantData : " << ptr)
             WXRUBY_TRACE_END
 
-            Variant_Value_Map.erase(ptr);
+            wxRuby_UnregisterCategoryValue(WXRUBY_VARIANT_DATA, ptr);
 
             WXRUBY_TRACE_IF(WxRubyTraceGCMarkVariant, 2)
               WXRUBY_TRACE("< wxRuby_UnregisterValueVariantData")
@@ -502,7 +507,6 @@ module WXRuby3
             return variant;
           }
           __HEREDOC
-        spec.add_init_code 'wxRuby_AppendMarker(GC_mark_RbValueVariants);'
         # ignore GetType (not doc)
         spec.ignore 'wxVariant::GetType', ignore_doc: false
         # replace with custom implementation

data/rakelib/lib/director/webview.rb

@@ -0,0 +1,166 @@
+# Copyright (c) 2023 M.J.N. Corino, The Netherlands
+#
+# This software is released under the MIT license.
+
+###
+# wxRuby3 wxWidgets interface director
+###
+
+require_relative './window'
+
+module WXRuby3
+
+  class Director
+
+    class WebView < Window
+
+      include Typemap::IOStreams
+      include Typemap::DateTime
+
+      def setup
+        spec.items << 'wxWebViewHistoryItem'
+        if Config.instance.wx_version_check('3.3.0') >= 0
+          spec.items << 'wxWebViewConfiguration'
+        end
+        super
+        if Config.instance.wx_version_check('3.3.0') >= 0
+          spec.gc_as_object 'wxWebViewConfiguration'
+          spec.no_proxy 'wxWebViewConfiguration'
+          spec.extend_interface 'wxWebViewConfiguration', 'wxWebViewConfiguration()', visibility: 'protected'
+          spec.make_abstract 'wxWebViewConfiguration'
+          # not useful in wxRuby
+          spec.ignore 'wxWebViewConfiguration::GetNativeConfiguration'
+        end
+        spec.gc_as_untracked 'wxWebViewHistoryItem'
+
+        spec.no_proxy 'wxWebView'
+        spec.ignore 'wxWebView::RegisterFactory'
+        spec.ignore 'wxWebView::GetNativeBackend'
+        if Config.instance.features_set?('WXMSW', 'USE_WEBVIEW_IE')
+          spec.include 'wx/msw/webview_ie.h', 'wx/msw/registry.h'
+          spec.add_extend_code 'wxWebView', <<~__CODE
+            // Have to add our own version here as wxw gets the execution module name wrong. 
+            static bool msw_set_ie_emulation_level(wxWebViewIE_EmulationLevel level = wxWEBVIEWIE_EMU_IE11)
+            {
+              // Registry key where emulation level for programs are set
+              static const wxChar* IE_EMULATION_KEY =
+                  wxT("SOFTWARE\\\\Microsoft\\\\Internet Explorer\\\\Main")
+                  wxT("\\\\FeatureControl\\\\FEATURE_BROWSER_EMULATION");
+          
+              wxRegKey key(wxRegKey::HKCU, IE_EMULATION_KEY);
+              // Check the existence of the key and create it if it does not exist
+              if ( !key.Exists() && !key.Create() )
+              {
+                  wxLogWarning(_("Failed to find web view emulation level in the registry"));
+                  return false;
+              }
+          
+              const wxString programName = wxT("ruby.exe");
+              if ( level != wxWEBVIEWIE_EMU_DEFAULT )
+              {
+                  if ( !key.SetValue(programName, level) )
+                  {
+                      wxLogWarning(_("Failed to set web view to modern emulation level"));
+                      return false;
+                  }
+              }
+              else
+              {
+                  if ( !key.DeleteValue(programName) )
+                  {
+                      wxLogWarning(_("Failed to reset web view to standard emulation level"));
+                      return false;
+                  }
+              }
+          
+              return true;
+            }
+            __CODE
+        else
+          spec.ignore 'wxWebViewIE_EmulationLevel'
+        end
+        if Config.instance.wx_version_check('3.1.1') >= 0
+          spec.map 'wxString *output' => 'String,nil' do
+            map_in ignore: true, temp: 'wxString tmp', code: '$1 = &tmp;'
+            map_out ignore: 'bool'
+            map_argout code: <<~__CODE
+              if (result)
+              {
+                $result = WXSTR_TO_RSTR(tmp$argnum);
+              }
+              else
+              {
+                $result = Qnil;
+              }
+              __CODE
+          end
+        end
+        if Config.instance.wx_version_check('3.1.6') >= 0
+          # do not support inherently unsafe 'void* clientData'
+          spec.ignore 'wxWebView::RunScriptAsync', ignore_doc: false
+          spec.add_extend_code 'wxWebView', <<~__CODE
+            void RunScriptAsync(const wxString& javascript)
+            {
+              $self->RunScriptAsync(javascript, nullptr);
+            }
+            __CODE
+          spec.map 'void* clientData', swig: false do
+            map_in ignore: true, code: ''
+          end
+        end
+
+        spec.add_swig_code <<~__CODE
+          %include <wx_ruby_shared_ptr.i>
+          %wx_ruby_shared_ptr(wxWebViewHandler, wxWebViewHandler);
+          %wx_ruby_shared_ptr(wxWebViewArchiveHandler, wxWebViewHandler);
+          %wx_ruby_shared_ptr(wxWebViewFSHandler, wxWebViewHandler);
+
+          %include <wx_shared_ptr.i>
+          %wx_shared_ptr(wxWebViewHistoryItem);
+          __CODE
+
+        spec.map 'wxSharedPtr<wxWebViewHandler>' => 'Wx::WebViewHandler>' do
+          map_in code: <<~__CODE
+            void* argp$argnum;
+            int res$argnum = SWIG_ConvertPtr($input, &argp$argnum, SWIGTYPE_p_WxRubySharedPtrT_wxWebViewHandler_wxWebViewHandler_t,  0 );
+            if (!SWIG_IsOK(res$argnum)) {
+              SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "WxRubySharedPtr< wxWebViewHandler, wxWebViewHandler >","RegisterHandler", 2, argv[0] )); 
+            }  
+            if (!argp2) {
+              SWIG_exception_fail(SWIG_NullReferenceError, Ruby_Format_TypeError("invalid null reference ", "WxRubySharedPtr< wxWebViewHandler, wxWebViewHandler >","RegisterHandler", 2, argv[0]));
+            } else {
+              arg2 = *(reinterpret_cast< WxRubySharedPtr< wxWebViewHandler, wxWebViewHandler > * >(argp2));
+            }
+            __CODE
+        end
+
+        spec.map 'wxVector< wxSharedPtr<wxWebViewHistoryItem> >' => 'Array<Wx::WEB::WebViewHistoryItem>' do
+          map_out code: <<~__CODE
+              $result = rb_ary_new();
+              wxVector< wxSharedPtr<wxWebViewHistoryItem> > *history = (wxVector< wxSharedPtr<wxWebViewHistoryItem> > *)&$1;
+              for (wxSharedPtr<wxWebViewHistoryItem>& hist_item : *history)
+              {
+                VALUE r_hist = SWIG_NewPointerObj(new wxSharedPtr<wxWebViewHistoryItem>(SWIG_STD_MOVE(hist_item)), SWIGTYPE_p_wxSharedPtrT_wxWebViewHistoryItem_t, SWIG_POINTER_OWN);
+                rb_ary_push($result, r_hist);
+              }
+            __CODE
+        end
+
+        spec.map 'wxSharedPtr<wxWebViewHistoryItem>' => 'Wx::WEB::WebViewHistoryItem', swig: false do
+          map_in code: ''
+        end
+
+        # fix event definitions
+        if Config.instance.wx_version_check('3.3.0') >= 0
+          # completely missing up and until 3.3.2 but should be there
+          if Config.instance.wx_version_check('3.3.2') <= 0
+            spec.add_swig_code %Q{%constant wxEventType wxEVT_WEBVIEW_BROWSING_DATA_CLEARED = wxEVT_WEBVIEW_BROWSING_DATA_CLEARED;}
+          end
+        end
+      end
+
+    end # class WebView
+
+  end # class Director
+
+end # module WXRuby3

data/rakelib/lib/director/webview_event.rb

@@ -0,0 +1,37 @@
+# Copyright (c) 2023 M.J.N. Corino, The Netherlands
+#
+# This software is released under the MIT license.
+
+###
+# wxRuby3 wxWidgets interface director
+###
+
+require_relative './event'
+
+module WXRuby3
+
+  class Director
+
+    class WebViewEvent < Event
+
+      def setup
+        super
+        spec.override_inheritance_chain('wxWebViewEvent',
+                                        {'wxNotifyEvent' => 'wxEvents'}, {'wxCommandEvent' => 'wxEvent'}, 'wxEvent', 'wxObject')
+        if Config.instance.wx_version_check('3.3.0') >= 0
+          spec.items << 'wxWebViewWindowFeatures'
+          spec.gc_as_untracked 'wxWebViewWindowFeatures'
+          spec.no_proxy 'wxWebViewWindowFeatures'
+          spec.make_abstract 'wxWebViewWindowFeatures'
+          spec.extend_interface 'wxWebViewWindowFeatures',
+                                'virtual wxWebViewWindowFeatures()',
+                                visibility: 'protected'
+
+        end
+        spec.do_not_generate(:variables, :defines, :enums, :functions)
+      end
+    end # class WebViewEvent
+
+  end # class Director
+
+end # module WXRuby3

data/rakelib/lib/director/webview_handler.rb

@@ -0,0 +1,63 @@
+# 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 WebViewHandler < Director
+
+      include Typemap::IOStreams
+      include Typemap::MBConv
+
+      def setup
+        spec.items.concat %w[wxWebViewArchiveHandler wxWebViewFSHandler]
+        if Config.instance.wx_version_check('3.3.0') >= 0
+          spec.items.concat %w[wxWebViewHandlerRequest wxWebViewHandlerResponse wxWebViewHandlerResponseData]
+        end
+        super
+        spec.gc_as_untracked 'wxWebViewHandler', 'wxWebViewArchiveHandler', 'wxWebViewFSHandler'
+        spec.make_abstract 'wxWebViewHandler'
+        spec.add_swig_code <<~__CODE
+            %include <wx_ruby_shared_ptr.i>
+            %wx_ruby_shared_ptr(wxWebViewHandler, wxWebViewHandler);
+            %wx_ruby_shared_ptr(wxWebViewArchiveHandler, wxWebViewHandler);
+            %wx_ruby_shared_ptr(wxWebViewFSHandler, wxWebViewHandler);
+            __CODE
+        if Config.instance.wx_version_check('3.3.0') >= 0
+          spec.gc_as_untracked 'wxWebViewHandlerRequest', 'wxWebViewHandlerResponse', 'wxWebViewHandlerResponseData'
+          spec.no_proxy 'wxWebViewHandlerRequest', 'wxWebViewHandlerResponse'
+          spec.make_abstract 'wxWebViewHandlerRequest'
+          spec.make_abstract 'wxWebViewHandlerResponse'
+          spec.make_abstract 'wxWebViewHandlerResponseData'
+          spec.add_swig_code <<~__CODE
+            %include <wx_shared_ptr.i>
+            %wx_shared_ptr(wxWebViewHandlerResponse);
+            %wx_shared_ptr(wxWebViewHandlerResponseData);
+            __CODE
+          spec.map 'wxSharedPtr<wxWebViewHandlerResponse>' => 'Wx::WEB::WebViewHandlerResponse', swig: false do
+            map_in code: ''
+          end
+          spec.map 'wxSharedPtr<wxWebViewHandlerResponseData>' => 'Wx::WEB::WebViewHandlerResponseData', swig: false do
+            map_in code: ''
+          end
+          spec.suppress_warning(473,
+                                'wxWebViewHandlerResponseData::GetStream')
+        end
+        spec.suppress_warning(473,
+                              'wxWebViewHandler::GetFile',
+                              'wxWebViewArchiveHandler::GetFile',
+                              'wxWebViewFSHandler::GetFile')
+        spec.do_not_generate(:variables, :defines, :enums, :functions)
+      end
+
+    end # class WebViewHandler
+
+  end # class Director
+
+end # module WXRuby3

data/rakelib/lib/generate/doc/thread_event.yaml

@@ -0,0 +1,20 @@
+---
+:wxThreadEvent:
+  :detail:
+    :pre:
+      :detaileddescription:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            This event is not natively emitted by any control/class: it is just a helper class for the user. 
+            Its most important feature is the {Wx::RT::ThreadEvent#get_event_category} implementation which allows 
+            thread events <b>NOT</b> to be processed by {Wx::GUIEventLoop#yield_for} calls (unless the 
+            {Wx::EventCategory::EVT_CATEGORY_THREAD} is specified - which is never in wx code).
+            
+            In wxRuby user defined classes can be derived from this class but it is important to note that when used
+            with {Wx::RT::SharedEvtHandler#queue_message} (the only imaginable use for thread events) no Ruby state
+            will <b>ever</b> persist and adding instance variables is therefor not useful.
+            The real benefit of being able to derive from this class is that it provides for the registration and use of 
+            user defined event types for the derived classes allowing to differentiate in event handling.
+            @see Wx::GUIEventLoop#yield_for
+            @see Wx::RT::SharedEvtHandler

data/rakelib/lib/generate/doc/web_view.yaml

@@ -0,0 +1,135 @@
+---
+:wxWebView:
+  :detail:
+    :pre:
+      :detaileddescription:
+        - :pattern: !ruby/regexp /wxWEBVIEW_BACKEND_IE\s+\(MSW\)/
+          :subst: 'Wx::WEB::WEBVIEW_BACKEND_IE (MSW)'
+        - :pattern: !ruby/regexp /Internet\s+Explorer\s+7/
+          :subst: 'Internet Explorer 11'
+        - :pattern: !ruby/regexp /wxWebViewIE::MSWSetEmulationLevel/
+          :subst: 'wxWebView::msw_set_ie_emulation_level'
+        - :pattern: !ruby/regexp /wxWebViewBackendIE/m
+          :global: true
+          :subst: 'wxWEBVIEW_BACKEND_IE'
+        - :pattern: !ruby/regexp /wxWEBVIEW_BACKEND_EDGE/m
+          :global: true
+          :subst: 'Wx::WEB::WEBVIEW_BACKEND_EDGE'
+        - :pattern: !ruby/regexp /wxWebViewBackendEdge/m
+          :global: true
+          :subst: 'wxWEBVIEW_BACKEND_EDGE'
+        - :pattern: !ruby/regexp /This\s+backend.*using\s+CMake.\s+To\s+build.*steps:/
+          :subst: 'This backend is enabled by default for WXMSW.'
+        - :pattern: !ruby/regexp /wxWebViewBackendWebKit/m
+          :global: true
+          :subst: 'wxWEBVIEW_BACKEND_WEBKIT'
+        - :pattern: !ruby/regexp /wxWEBVIEW_WEBKIT/m
+          :global: true
+          :subst: 'Wx::WEB::WEBVIEW_BACKEND_WEBKIT'
+        - :pattern: !ruby/regexp /wxWEBVIEW_CHROMIUM/m
+          :global: true
+          :subst: 'Wx::WEB::WEBVIEW_BACKEND_CHROMIUM'
+        - :pattern: !ruby/regexp /wxWebViewBackendChromium/m
+          :global: true
+          :subst: 'wxWEBVIEW_BACKEND_CHROMIUM'
+      :programlisting:
+        - :pattern: !ruby/regexp /wxSetEnv/
+          :replace: |
+            
+            
+            ```ruby
+             ENV['WEBKIT_DISABLE_DMABUF_RENDERER'] = '1'
+            ```
+
+    :post:
+      - :pattern: !ruby/regexp /-\s+When\s+not\s+using\s+CMake:.*remove\s+the dependency\s+on\s+WebView2Loader\.dll\s+at runtime./m
+        :subst: ''
+      - :pattern: !ruby/regexp /If.*fixed\s+version.*WebView2.*Edge\s+backend\./
+        :subst: ''
+      - :pattern: !ruby/regexp /see\s+\{Wx::WebViewChromium\}.*build\s+instructions./
+        :subst: |
+          see the wxWidgets documentation for wxWebViewChromium for additional usage and build instructions.
+          This backend can not be automatically build by the wxRuby3 build scripts but requires a custom wxWidgets installation.
+          See the wxRuby3 INSTALL documentation for details on how to build with a custom wxWidgets setup.
+:wxWebView.RunScript:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /document\.write/
+          :replace: |
+            
+            
+            ```ruby
+             webview.run_script('document.write('Hello from wxWidgets!')')
+            ```
+
+        - :pattern: !ruby/regexp /document\.getElementById/
+          :replace: |
+            
+            
+            ```ruby
+               if (result = webview.run_script('document.getElementById('some_id').innerHTML'))
+                   #... result contains the contents of the given element ...
+               # else: the element with this ID probably doesn't exist.
+               end
+            ```
+
+    :post:
+      - :pattern: !ruby/regexp /return\s+false/m
+        :global: true
+        :subst: 'return nil'
+      - :pattern: !ruby/regexp /MSWSetEmulationLevel\(\)/
+        :subst: 'Wx::WEB::WebView::msw_set_ie_emulation_level'
+      - :pattern: !ruby/regexp /If.*output.*success/m
+        :subst: 'This method returns the result of executing this code on success (or nil if no result or on failure)'
+      - :pattern: !ruby/regexp /true\s+if\s+there\s+is.*error./m
+        :subst: ''
+:wxWebView.AddScriptMessageHandler:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /AddScriptMessageHandler/
+          :replace: |
+            
+            
+            ```ruby
+               # Install message handler with the name wx_msg
+               @webView.add_script_message_handler("wx_msg")
+               # Bind handler
+               @webView.evt_webview_script_message_received(Wx::ID_ANY) { |evt|
+                   Wx.log_message("Script message received; value = %s, handler = %s", evt.get_string, evt.get_message_handler)
+               }
+            ```
+
+    :post:
+      - :pattern: !ruby/regexp /Sample\s+C\+\+\s+code\s+/
+        :subst: 'Sample code '
+:wxWebView.SetProxy:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            
+            ```ruby
+              webview = Wx::WEB::WebView.new
+              unless webview.set_proxy("http://127.0.0.1:8080")
+                  Wx.log_warning("Setting proxy failed!")
+              end
+              webview.create(parent, Wx::ID_ANY)
+            ```
+
+:wxWebView.IsBackendAvailable:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            
+            ```ruby
+              if Wx::WEB::WebView::is_backend_available(Wx::WEB::WEBVIEW_BACKEND_EDGE)
+                  #... enable some extra functionality not available with the IE backend ...
+              end
+            ```

data/rakelib/lib/generate/doc/web_view_event.yaml

@@ -0,0 +1,38 @@
+---
+:wxWebViewWindowFeatures:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /wxEVT_WEBVIEW_NEWWINDOW/
+          :replace: |
+            
+            
+            ```ruby
+              # Bind new window handler
+              @webView.evt_webview_newwindow(Wx::ID_ANY) { |evt|
+                if evt.get_url == "http://badwebsite.com"
+                  evt.veto # Disallow new window for badwebsite.com
+                else
+                  evt.skip # Allow new window for all other websites
+                end    
+              }
+              
+              # Bind new window features handler
+              @webView.evt_webview_newwindow_features(Wx::ID_ANY) { |evt|
+                 # Get target window features
+                 features = evt.get_target_window_features
+                 # Create a top level window for the child web view
+                 win = Wx::Frame.new(nil, Wx::ID_ANY, features.get_position, features.get_size)
+                 sizer = Wx::VBoxSizer.new
+                 win.set_sizer(sizer)
+                 # Get the child web view
+                 childWebView = features.get_child_web_view
+                 # Place the child web view into the window
+                 childWebView.create(win, Wx::ID_ANY)
+                 sizer.add(childWebView, Wx::SizerFlags.new.proportion(1).expand)
+              }
+            ```
+
+    :post:
+      - :pattern: !ruby/regexp /Sample\s+C\+\+\s+code\s+/
+        :subst: 'Sample code '

data/rakelib/lib/generate/doc/web_view_handler.yaml

@@ -0,0 +1,58 @@
+---
+:wxWebViewHandler.SetVirtualHost:
+  :detail:
+    :post:
+      - :pattern: !ruby/regexp /name\.\{Wx::site\}/
+        :subst: '<code>name.wxsite</code>'
+:wxWebViewHandler.StartRequest:
+  :detail:
+    :pre:
+      :programlisting:
+        - :pattern: !ruby/regexp /.*/
+          :replace: |
+            
+            ```ruby
+            def start_request(request, response)
+               # Set common headers allowing access from XMLHTTPRequests()
+               response.set_header("Access-Control-Allow-Origin", "*")
+               response.set_header("Access-Control-Allow-Headers", "*")
+            
+               # Handle options request
+               if request.get_method.casecmp("options") == 0
+                 response.finish("")
+                 return
+               end
+            
+               # Check the post data type
+               unless request.get_header("Content-Type").start_with?("application/json")
+                 response.finish_with_error
+                 return;
+               end
+            
+               # Process input data
+               postData = request.get_data_string
+            
+               #...
+            
+               # Send result
+               response.set_content_type("application/json")
+               response.finish("{ result: true }")
+            end
+            ```
+:wxWebViewHandlerResponse.Finish:
+  :detail:
+    :pre:
+      :detaileddescription:
+        - :pattern: !ruby/regexp /simplesect.*kind.*see.*Finish.*wxMBConv/
+          :replace: |
+            @see finish(text, conv)
+        - :pattern: !ruby/regexp /simplesect.*kind.*see.*Finish.*wxWebViewHandlerResponseData/
+          :replace: |
+            @see find(data)
+:wxWebViewHandlerResponseData:
+  :detail:
+    :pre:
+      :detaileddescription:
+        - :pattern: !ruby/regexp /simplesect.*kind.*see.*Finish.*wxWebViewHandlerResponseData/
+          :replace: |
+            @see Wx::WEB::WebViewHandlerResponse#finish(data)

data/rakelib/lib/specs/interfaces.rb

@@ -248,12 +248,18 @@ module WXRuby3
     Director.Spec(pkg, 'wxPersistentWindow', requirements: %w[USE_CONFIG])
     Director.Spec(pkg, 'wxSecretStore', requirements: %w[USE_SECRETSTORE])
     Director.Spec(pkg, 'wxDCOverlay', director: Director::DerivedDC)
-    Director.Spec(pkg, 'wxGeometry', requirements: %w[USE_GEOMETRY])
-    Director.Spec(pkg, 'wxAffineMatrix2D', requirements: %w[USE_GEOMETRY])
+    Director.Spec(pkg, 'wxGeometry', requirements: Config.instance.wx_version_check('3.3.2') <= 0 ?  %w[USE_GEOMETRY] : [])
+    Director.Spec(pkg, 'wxAffineMatrix2D', requirements: Config.instance.wx_version_check('3.3.2') <= 0 ?  %w[USE_GEOMETRY] : [])
     Director.Spec(pkg, 'wxCredentialEntryDialog', director: Director::Dialog, requirements: %w[USE_CREDENTIALDLG])
     Director.Spec(pkg, 'wxGenericAboutDialog', director: Director::Dialog, requirements: %w[USE_ABOUTDLG])
+    Director.Spec(pkg, 'wxMBConv')
   }
 
+  Director.Package('Wx::RT', 'USE_THREADS') do |pkg|
+    Director.Spec(pkg, 'wxSharedEvtHandler')
+    Director.Spec(pkg, 'wxThreadEvent')
+  end
+
   Director.Package('Wx::PRT', 'USE_PRINTING_ARCHITECTURE') do |pkg|
     Director.Spec(pkg, 'wxPrinterDC', director: Director::DerivedDC, requirements: Director.AnyOf(*%w[WXMSW WXOSX USE_GTKPRINT]))
     Director.Spec(pkg, 'wxPostScriptDC', director: Director::DerivedDC)
@@ -387,4 +393,10 @@ module WXRuby3
     Director.Spec(pkg, 'wxRibbonToolBar')
     Director.Spec(pkg, 'wxRibbonButtonBar')
   }
+
+  Director.Package('Wx::WEB', 'USE_WEBVIEW') { |pkg|
+    Director.Spec(pkg, 'wxWebViewHandler')
+    Director.Spec(pkg, 'wxWebView')
+    Director.Spec(pkg, 'wxWebViewEvent')
+  }
 end # module WXRuby3

data/rakelib/lib/typemap/common.rb

@@ -532,7 +532,7 @@ module WXRuby3
 
         # window/sizer object wrapping
 
-        map 'wxWindow*' => 'Wx::Window', 'wxSizer*' => 'Wx::Sizer' do
+        map 'wxWindow*' => 'Wx::Window', 'wxControl*' => 'Wx::Control', 'wxSizer*' => 'Wx::Sizer' do
           map_out code: '$result = wxRuby_WrapWxObjectInRuby($1);'
         end
 
@@ -605,6 +605,39 @@ module WXRuby3
             __CODE
         end
 
+        # Menu bars need to be wrapped / unwrapped correctly
+        map 'wxMenuBar*' => 'Wx::MenuBar' do
+          add_header_code <<~__CODE
+            WXRUBY_EXPORT VALUE wxRuby_WrapWxMenuBarInRuby(wxMenuBar *wx_menubar);
+            WXRUBY_EXPORT void wxRuby_RegisterWxMenuBar(wxMenuBar* wx_menubar, VALUE rb_menubar);
+            __CODE
+          map_check code: <<~__CODE
+            wxRuby_RegisterWxMenuBar($1, argv[$argnum-2]);                     
+            __CODE
+          map_out code: <<~__CODE
+            $result = wxRuby_WrapWxMenuBarInRuby($1);
+            __CODE
+          map_directorin code: <<~__CODE
+            $input = wxRuby_WrapWxMenuBarInRuby($1);
+            __CODE
+        end
+        # As do menus
+        map 'wxMenu*' => 'Wx::Menu' do
+          add_header_code <<~__CODE
+            WXRUBY_EXPORT VALUE wxRuby_WrapWxMenuInRuby(wxMenu *wx_menu);
+            WXRUBY_EXPORT void wxRuby_RegisterWxMenu(wxMenu* wx_menu, VALUE rb_menu);
+            __CODE
+          map_check code: <<~__CODE
+            wxRuby_RegisterWxMenu($1, argv[$argnum-2]);                     
+            __CODE
+          map_out code: <<~__CODE
+            $result = wxRuby_WrapWxMenuInRuby($1);
+            __CODE
+          map_directorin code: <<~__CODE
+            $input = wxRuby_WrapWxMenuInRuby($1);
+            __CODE
+        end
+
         # typemap to allow String or Symbol for wxColour in args
         map 'const wxColour&', 'const wxColour*', as: 'Wx::Colour,String,Symbol' do
           map_in temp: 'wxColour tmpcol', code: <<~__CODE