wxruby3 1.7.0 → 1.8.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 29b2e3949b365c4778d3b537d91f6b227361bcc3f978fa2c92bdea5e2c81390c
-  data.tar.gz: 58e28a379655680b2c7b5ac147436f154102bc551d356b8bd2d4f7a57249fa2f
+  metadata.gz: 686537c22871168bb80d09ecffbc7170b1de0560930014b579ee35dd3f71f80d
+  data.tar.gz: 8ea1c3c592fd0ecc5e5922f7a3fabe12def1b97a76e30a88b0f576e90fdcca8b
 SHA512:
-  metadata.gz: fa954320cb8c4a44872a78fe5c5da098d5b15667b93b3d9b6f24839fb17a04e42b2d4ccd8eed502407a0eed348cba08da19abdeaab99d8121c5e49674b931227
-  data.tar.gz: 7dd47c4496313f52a56ac7387ac195ad4a54ce5758b9015bb92eb5a6a7d8a98b27d8d9b96f06aa12850d613e74e51147fe82a7bdfe5541466c179f73dd7c964d
+  metadata.gz: 60b6061a6746bf5185e54d7c5df8de624beb633ead75d00b256d87c521c392bd7dab7f8259c061e6622bc31d4559e5a9d664914a87215c08634b74b2d9711e03
+  data.tar.gz: 3aa90ee4d255248e7678fed9a4bce668eb8cf01b7f36ff4f43dda3fff99f44d6eb37b607acdd1de26c63101fe3757e3d5b88d88020dd05dcbc87a283b40b9642

data/INSTALL.md

@@ -82,6 +82,11 @@ The following tables lists the packages provided by the current wxRuby3 release
 | OSX     | MacOS 15                               | x86_64 <b>and</b> ARM64 | Latest stable Ruby                                 |
 | OSX     | MacOS 26                               | x86_64 <b>and</b> ARM64 | Latest stable Ruby                                 |
 
+### Additional packages
+
+Some additional packages built from local resources may be added to the standard release artifacts (like for example for 
+LinuxMint x86_64) but this will also depend on available time and resources.
+
 ### User created packages
 
 Users can create their own wxRuby3 binary packages by building from source ([see here](#building-from-source)) and after
@@ -102,7 +107,7 @@ The software requirements for setting up a wxRuby3 runtime environment are:
 
 | Sofware                                       | Notes                                                                                                                                                                                                                                                                                                                        |
 |-----------------------------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| Ruby >= 2.7                                   | A supported version of the Ruby interpreter needs to be installed. This is an absolute requirement for any installation as one cannot install gems without Ruby and building from source requires Ruby to drive the build process.                                                                                           |
+| Ruby >= 3.0                                   | A supported version of the Ruby interpreter needs to be installed. This is an absolute requirement for any installation as one cannot install gems without Ruby and building from source requires Ruby to drive the build process.                                                                                           |
 | C++ compiler<br>(incl. dev tools like `make`) | Required for a source based installation to build wxWidgets (optionally) and the wxRuby extension libraries.<br/>On linux a recent version of the GNU C++ compiler (with c++-14 support) is required.<br>On Windows the RubyInstaller MSYS2-Devkit would be required.<br>On MacOS XCode with commandline tools would be required. |
 | Git version control toolkit                   | Required for a source based installation in to (possibly) clone a copy of the wxWidgets Github repository or to clone the Github repository of wxRuby3 itself for a fully source based installation.                                                                                                                         |
 | Doxygen (>= 1.9.1)                            | Required for building the wxRuby3 extension libraries for a source based installation. [**1**]                                                                                                                                                                                                                               |
@@ -116,7 +121,7 @@ But of course any of these requirements can also be fulfilled explicitly with se
 wxRuby3 installation procedure. See the platform specific sections of [Installing software requirements](INSTALL.md#installing-software-requirements) for details on 
 how to go about that. 
 
-[**1**] The wxRuby3 build process needs doxygen to generated XML files containing wxWidgets interface specs which are used to 
+[**1**] The wxRuby3 build process needs doxygen to generate XML files containing wxWidgets interface specs which are used to 
 generate interface definitions for SWIG
 
 [**2**] The wxRuby3 build process uses SWIG to generate C++ source code for the wrapper interfaces from
@@ -368,6 +373,26 @@ Note that in this case `--with-wxwin` is implied.
 > workflows of the [wxRuby3 Github Actions](https://github.com/mcorino/wxRuby3/actions) to get a feel of the current 
 > integration state. 
 
+#### Controlling included modules for embedded wxWidgets
+
+When building wxRuby3 with embedded wxWidgets (implicit or explicit) there are some setup arguments to control the
+modules included in the wxRuby3 installation.
+If none of these options are specified __all__ modules will be included by default.
+
+Note that these option only have effect if building with embedded wxWidgets. When building for wxWidgets system or user 
+installation, module support will be determined by the build options supplied when building that wxWidgets installation.
+
+##### WebView module
+
+To explicitly include the wxWidgets WebView library for the Wx::WEB::WebView module (the default) add the 
+`--with-webview` option. To explicitly specify which WebView backends should be supported it is possible to use the
+option like `--with-webview=<backend>[,<backend>`.
+On Windows __<backend\>__ can be `edge` and/or `ie`. By default, if no backend is specified, only the `edge` backend
+will be supported on Windows.
+On Linux and MacOS currently only the `webkit` backend is supported.
+
+To explicitly exclude WebView support add the `--without-webview` option. 
+
 #### Setup with user installed wxWidgets
 
 In case of a (custom) user installation of wxWidgets the `--wxwin` (and optionally `--wxxml`) option(s) can be used to

data/README.md

@@ -65,7 +65,7 @@ Wx::App.run { TheFrame.new('Hello world!').show }
 ## wxRuby3 licence
 
 wxRuby3 is free and open-source. It is distributed under the liberal
-MIT licence which is compatible with both free and commercial development.
+MIT license which is compatible with both free and commercial development.
 See [LICENSE](LICENSE) for more details.
 
 ### wxRuby3 and wxWidgets
@@ -76,7 +76,7 @@ those requirements do not impose any serious restrictions.
 
 ### wxWidgets License Summary (from wxWidgets)
 
-In summary, the licence is LGPL plus a clause allowing unrestricted
+In summary, the license is LGPL plus a clause allowing unrestricted
 distribution of application binaries. To answer a FAQ, you don't have to
 distribute any source if you wish to write commercial applications using
 wxWidgets.
@@ -97,23 +97,23 @@ of these products.
  
 ### What platforms and operating systems are supported in wxRuby3?
 
-Currently the following are fully supported:
+Currently, the following are fully supported:
 
 | Platform                                                                                                                                               | Ruby version(s)                                            | wxWidgets version(s) |
 |--------------------------------------------------------------------------------------------------------------------------------------------------------|------------------------------------------------------------|----------------------|
-| Windows >= 10                                                                                                                                          | Ruby >= 2.7<br>(RubyInstaller MSYS2-DevKit)                | wxWidgets >= 3.2     |
-| Linux (tested; all major AMD64 and ARM64 distributions: Ubuntu, Debian, Fedora, OpenSuSE, LinuxMint, Manjaro and ArchLinux)<br>(most likely also i686) | Ruby >= 2.7                                                | wxWidgets >= 3.2     |
-| MacOS >= 14 (MacOS 13 most likely also works) using Cocoa (tested on AMD64 and ARM64 M1/M2 Chip)                                                       | Ruby >= 2.7 (MacPorts, Homebrew, ruby-install, RVM, Rbenv) | wxWidgets >= 3.2     |
+| Windows >= 10                                                                                                                                          | Ruby >= 3.0<br>(RubyInstaller MSYS2-DevKit)                | wxWidgets >= 3.2     |
+| Linux (tested; all major AMD64 and ARM64 distributions: Ubuntu, Debian, Fedora, OpenSuSE, LinuxMint, Manjaro and ArchLinux)<br>(most likely also i686) | Ruby >= 3.0                                                | wxWidgets >= 3.2     |
+| MacOS >= 14 (MacOS 13 most likely also works) using Cocoa (tested on AMD64 and ARM64 M1/M2 Chip)                                                       | Ruby >= 3.0 (MacPorts, Homebrew, ruby-install, RVM, Rbenv) | wxWidgets >= 3.2     |
 
 Support for other platforms is not being actively developed at present,
 but patches are welcome. It is likely to be much simpler to get wxRuby
-working on similar modern systems (eg FreeBSD or Solaris with GTK) than
-on legacy systems (eg Windows 98, Mac OS 9).
+working on similar modern systems (e.g. FreeBSD or Solaris with GTK) than
+on legacy systems (e.g. Windows 98, macOS 9).
 
 ### How can I install wxRuby3?
 
 wxRuby3 is distributed as a Ruby gem on [RubyGems](https://rubygems.org). This gem can also be downloaded from the release 
-assets on [Github](https://github.com/mcorino/wxRuby3/releases).
+assets on [GitHub](https://github.com/mcorino/wxRuby3/releases).
 
 The wxRuby3 gem provides a **worry-free** installation procedure for all supported platforms.  
 
@@ -124,7 +124,7 @@ supported version of the Ruby interpreter. So the following command is all it ta
 gem install wxruby3
 ```
 
-The wxRuby3 installation procedure will check the availability of a, prebuilt, binary package matching the platform
+The wxRuby3 installation procedure will check the availability of a prebuilt, binary package matching the platform
 being installed on and if found will download and install that package resulting in a ready-to-run wxRuby3 installation.<br>
 If no matching package is found the installation reverts to a source installation which will require an additional setup
 step to finalize the wxRuby3 installation by executing the following command:
@@ -135,7 +135,7 @@ wxruby setup
 
 This last command is a fully automated setup procedure provided by the wxRuby3 **CLI** installed with the gem. This 
 procedure (by default) will analyze your system and install (after asking your consent) any missing software 
-requirements and build the wxRuby3 extension libraries (including a embedded copy of wxWidgets if necessary). It may 
+requirements and build the wxRuby3 extension libraries (including an embedded copy of wxWidgets if necessary). It may 
 take quite a while depending on your system (around 10-15 minutes on a modern PC but could be significantly longer
 on 'older' PC's) but you can mostly sit back and relax.
 
@@ -146,11 +146,11 @@ on 'older' PC's) but you can mostly sit back and relax.
 > on like the nokogiri gem).
 
 The wxRuby3 CLI also provides a 'check' command with which the runtime status of the wxRuby3 installation can be checked
-at any time. By default running `wxruby check` will display a message reporting the runtime and suggestions on finalizing
+at any time. By default, running `wxruby check` will display a message reporting the runtime and suggestions on finalizing
 the installation if not finalized yet. No message is displayed if wxRuby3 is ready to run. Run `wxruby check -h` for 
 details concerning this command. 
 
-A selection of (prebuilt) binary packages is provided as release assets on [Github](https://github.com/mcorino/wxRuby3/releases).
+A selection of (prebuilt) binary packages is provided as release assets on [GitHub](https://github.com/mcorino/wxRuby3/releases).
 See the [INSTALL](INSTALL.md#binary-packages) document for more details.
 
 This install procedure can of course be tweaked and customized with commandline arguments.
@@ -158,7 +158,7 @@ See the [INSTALL](INSTALL.md) document for more details.
 
 ### Where can I ask a question, or report a bug?
 
-Use GitHUb Issues.
+Use GitHub Issues.
 
 When asking a question, if something is not working as you expect,
 please provide a *minimal*, *runnable* sample of code that demonstrates
@@ -215,7 +215,7 @@ stopped in early 2005, in favour of what became wxRuby 2.0. This project
 in turn stopped being supported in 2013.
 Several years of development have passed for wxWidgets and Ruby respectively,
 improving code quality, adding new classes and new language features.
-In 2022 I finally found the time and the inspiration to pick up this project
+In 2022, I finally found the time and the inspiration to pick up this project
 with the idea of reviving it to build some applications I had in mind.
 wxRuby 3 intends to provide Ruby interfaces for all relevant (!) wxWidget
 classes of the latest version 3.2 and beyond. 

data/ext/wxruby3/include/wxRubyApp.h

@@ -8,6 +8,14 @@ WXRUBY_TRACE_GUARD(WxRubyTraceAppRun, "APP_RUN")
 
 #include <memory>
 
+#include <ruby/ractor.h>
+
+#include <wx/scopedptr.h>
+#include <wx/evtloop.h>
+
+// this defines wxEventLoopPtr
+wxDEFINE_TIED_SCOPED_PTR_TYPE(wxEventLoopBase)
+
 /*
  * WxRuby3 App class
  */
@@ -17,14 +25,133 @@ class wxRubyApp : public wxApp
 private:
   bool is_running_ = false;
   VALUE self_ = Qnil;
+
+  void _store_ruby_exception(VALUE ex)
+  {
+    rb_iv_set(this->self_, "@exception", ex);
+  }
+
+  class EventLoop : public wxGUIEventLoop
+  {
+  public:
+    int GetExitCode() { return this->exit_code_; }
+
+  protected:
+    virtual int DoRun() override
+    {
+      static WxRuby_ID count_id("count");
+      static WxRuby_ID list_id("list");
+      static WxRuby_ID pass_id("pass");
+
+      // run our own event loop
+      bool needs_idle_evt = true;
+      for (;;)
+      {
+        while ( !m_shouldExit
+                    && !Pending()
+                        && !(wxTheApp && wxTheApp->HasPendingEvents()) )
+        {
+          // check Ruby Ractors and/or Threads
+          bool needs_pass = false;
+          VALUE result  = rb_funcall(rb_cRactor, count_id(), 0);
+          needs_pass = !RB_NIL_P(result) && NUM2INT(result) > 1;
+          if (!needs_pass)
+          {
+            result = rb_funcall(rb_cThread, list_id(), 0);
+            needs_pass = !RB_NIL_P(result) && TYPE(result) == T_ARRAY && RARRAY_LEN(result) > 1;
+          }
+          if (needs_pass)
+          {
+            // call Thread.pass
+            bool ex_caught = false;
+            result  = wxRuby_Funcall(ex_caught, rb_cThread, pass_id(), 0, 0);
+            if (ex_caught)
+            {
+#ifdef __WXRB_DEBUG__
+              wxRuby_PrintException(result);
+#endif
+              wxRubyApp::GetInstance()->_store_ruby_exception(result);
+              this->exit_code_ = 1;
+              m_shouldExit = true;
+            }
+          }
+
+          if (!m_shouldExit && needs_idle_evt)
+          {
+            needs_idle_evt = ProcessIdle();
+            if (needs_idle_evt)
+              break;
+          }
+        }
+
+        // if Exit() was called, don't dispatch any more events here
+        if (m_shouldExit)
+            break;
+
+        // process pending wx events first as they correspond to low-level events
+        // which happened before, i.e. typically pending events were queued by a
+        // previous call to Dispatch() and if we didn't process them now the next
+        // call to it might enqueue them again (as happens with e.g. socket events
+        // which would be generated as long as there is input available on socket
+        // and this input is only removed from it when pending event handlers are
+        // executed)
+        if ( wxTheApp && wxTheApp->HasPendingEvents() )
+        {
+            wxTheApp->ProcessPendingEvents();
+
+            // One of the pending event handlers could have decided to exit the
+            // loop so check for the flag before trying to dispatch more events
+            // (which could block indefinitely if no more are coming).
+            if ( m_shouldExit )
+                break;
+        }
+
+        // nothing doing, so just wait max 1 msec for an event
+        if (this->DispatchTimeout(1) == 0 && m_shouldExit)
+          break; // stop event loop
+
+        needs_idle_evt = true;
+      }
+
+      return this->exit_code_;
+    }
+
+#if (wxMAJOR_VERSION > 3) || (wxMINOR_VERSION > 2)
+    virtual void DoStop(int rc) override
+    {
+      this->exit_code_ = rc;
+#if !defined(__WXGTK__)
+      wxGUIEventLoop::DoStop(rc);
+#endif
+    }
+#else
+    virtual void ScheduleExit(int rc) override
+    {
+      this->exit_code_ = rc;
+#if defined(__WXGTK__)
+      m_shouldExit = true;
+#else
+      wxGUIEventLoop::ScheduleExit(rc);
+#endif
+    }
+#endif
+
+  private:
+    int exit_code_ {};
+  };
+
 public:
   static wxRubyApp* GetInstance () { return dynamic_cast<wxRubyApp*> (wxApp::GetInstance()); }
 
   virtual ~wxRubyApp()
   {
-#ifdef __WXTRACE__
-  std::wcout << "~wxRubyApp" << std::endl;
-#endif
+    WXRUBY_TRACE_IF(WxRubyTraceAppRun, 1)
+      WXRUBY_TRACE("> ~wxRubyApp this=" << this)
+    WXRUBY_TRACE_END
+
+    // app is also event handler, so cleanup
+    wxRuby_ReleaseEvtHandlerProcs(this);
+
     // unlink
     if (this->self_ != Qnil)
     {
@@ -54,39 +181,9 @@ public:
 
   bool IsRunning() const { return this->is_running_; }
 
-  // When ruby's garbage collection runs, if the app is still active, it
-  // cycles through all currently known SWIG objects and calls this
-  // function on each to preserve still active Wx::Windows, and also
-  // pending Wx::Events which have been queued from the Ruby side (the
-  // only sort of events that will be in the tracking hash.
-  static void markIterate(void* ptr, VALUE rb_obj)
-  {
-    // Check if it's a valid object (sometimes SWIG doesn't return what we're
-    // expecting), a descendant of Wx::Window (but not a Dialog), and if it has not yet been
-    // deleted by WxWidgets; if so, mark it.
-    if ( TYPE(rb_obj) == T_DATA )
-    {
-      if ( rb_obj_is_kind_of(rb_obj, wxRuby_GetWindowClass()) )
-      {
-        rb_gc_mark(rb_obj);
-      }
-      else if (rb_obj_is_kind_of(rb_obj, wxRuby_GetDefaultEventClass()) )
-        rb_gc_mark(rb_obj);
-    }
-//    else if (TYPE(rb_obj) == T_ARRAY )
-//    {
-//      VALUE proc = rb_ary_entry(rb_obj, 0);
-//      if (rb_obj_is_kind_of(proc, rb_cProc) || rb_obj_is_kind_of(proc, rb_cMethod))
-//      {
-//        // keep the async call alive
-//        rb_gc_mark(rb_obj);
-//      }
-//    }
-  }
-
   // Implements GC protection across wxRuby. Always called because
   // Wx::THE_APP is a constant so always checked in GC mark phase.
-  static void mark_wxRubyApp(void *ptr)
+  static void GC_mark_wxRubyApp(void *ptr)
   {
     WXRUBY_TRACE_IF(WxRubyTraceMarkApp, 1)
       WXRUBY_TRACE(">=== Starting App GC mark phase")
@@ -116,16 +213,8 @@ public:
     // classes/EvtHandler.i
     wxRuby_MarkProtectedEvtHandlerProcs();
 
-    // run registered markers
-    for (wxVector<WXRBMarkFunction>::iterator it = WXRuby_Mark_List.begin();
-          it != WXRuby_Mark_List.end() ;++it)
-    {
-      (*it) ();
-    }
-
-    // To do the main marking, primarily of Windows, iterate over SWIG's
-    // list of tracked objects
-    wxRuby_IterateTracking(&wxRubyApp::markIterate);
+    // Mark all tracked objects (as applicable)
+    wxRuby_MarkTracked();
 
     WXRUBY_TRACE_IF(WxRubyTraceMarkApp, 1)
       WXRUBY_TRACE("<=== App GC mark phase completed")
@@ -207,6 +296,16 @@ public:
     return rc;
   }
 
+  virtual int MainLoop() override
+  {
+    wxEventLoopBaseTiedPtr main_loop(&m_mainLoop, new wxRubyApp::EventLoop);
+
+    if (wxTheApp)
+        wxTheApp->OnLaunched();
+
+    return m_mainLoop ? m_mainLoop->Run() : -1;
+  }
+
   // This method initializes the stock objects (Pens, Brushes, Fonts)
   // before yielding to ruby by calling the App's on_init method.
   // Note that as of wxWidget 2.8, the stock fonts in particular cannot
@@ -234,7 +333,7 @@ public:
 #ifdef __WXRB_DEBUG__
       wxRuby_PrintException(result);
 #endif
-      rb_iv_set(this->self_, "@exception", result);
+      _store_ruby_exception(result);
       result = Qfalse; // exit app
     }
 
@@ -274,7 +373,7 @@ public:
 #ifdef __WXRB_DEBUG__
         wxRuby_PrintException(rc);
 #endif
-        rb_iv_set(this->self_, "@exception", rc);
+        _store_ruby_exception(rc);
       }
     }
 

data/ext/wxruby3/include/wxruby-ComboPopup.h

@@ -12,6 +12,9 @@
 #include <wx/combo.h>
 #include <map>
 
+
+static void wxRuby_markComboPopups(const TGCTrackingValueMap& values);
+
 class WxRubyComboPopup : public wxComboPopup
 {
 private:
@@ -31,7 +34,7 @@ private:
   static WxRuby_ID on_popup_ID;
   static WxRuby_ID paint_combo_control_ID;
 
-  static std::map<WxRubyComboPopup*, VALUE> combo_popup_map;
+  static const std::string WXRUBY_COMBO_POPUP;
 
   VALUE rb_combo_popup_;
 
@@ -44,11 +47,11 @@ private:
   };
 
 public:
-  static void GC_mark_combo_popups()
+  static void GC_mark_combo_popups(const TGCTrackingValueMap& values)
   {
-    for (auto pair : combo_popup_map)
+    for (const auto& ti : values)
     {
-      rb_gc_mark(pair.second);
+      rb_gc_mark(ti.second);
     }
   }
 
@@ -56,14 +59,23 @@ public:
     : wxComboPopup()
     , rb_combo_popup_(rb_cp)
   {
-    combo_popup_map[this] = rb_cp; // register
+    static bool is_marker_registered = false;
+
+    if (!is_marker_registered)
+    {
+      wxRuby_RegisterTrackingCategory(WXRUBY_COMBO_POPUP, wxRuby_markComboPopups, true);
+      is_marker_registered = true;
+    }
+    // register for tracking
+    wxRuby_RegisterCategoryValue(WXRUBY_COMBO_POPUP, this, rb_cp);
   }
 
   virtual ~WxRubyComboPopup()
   {
     if (!NIL_P(rb_combo_popup_))
     {
-      combo_popup_map.erase(this); //deregister
+      // unregister from tracking
+      wxRuby_UnregisterCategoryValue(WXRUBY_COMBO_POPUP, this);
       // unlink
       rb_iv_set(rb_combo_popup_, "@_wx_combo_popup_proxy", Qnil);
       rb_combo_popup_ = Qnil;
@@ -197,6 +209,13 @@ public:
 
 };
 
+const std::string WxRubyComboPopup::WXRUBY_COMBO_POPUP = {"WXRUBY_COMBO_POPUP"};
+
+static void wxRuby_markComboPopups(const TGCTrackingValueMap& values)
+{
+  WxRubyComboPopup::GC_mark_combo_popups(values);
+}
+
 WxRuby_ID WxRubyComboPopup::init_ID("init");
 WxRuby_ID WxRubyComboPopup::lazy_create_ID("lazy_create");
 WxRuby_ID WxRubyComboPopup::create_ID("create");
@@ -213,8 +232,6 @@ WxRuby_ID WxRubyComboPopup::on_dismiss_ID("on_dismiss");
 WxRuby_ID WxRubyComboPopup::on_popup_ID("on_popup");
 WxRuby_ID WxRubyComboPopup::paint_combo_control_ID("paint_combo_control");
 
-std::map<WxRubyComboPopup*, VALUE> WxRubyComboPopup::combo_popup_map;
-
 // Wrapper methods for module Wx::ComboPopup
 
 static VALUE wx_combo_popup_get_combo_ctrl(int argc, VALUE *argv, VALUE self)