wxruby3 0.9.1 → 0.9.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8b5236fc5965ca7cb7f44f6ffa69c74af04529217c2ac85178b04b719781407c
-  data.tar.gz: 745d4f4b7b6168a764d47dfa640128666a57922bf90c9d43757a7726ae4d3c75
+  metadata.gz: ef007e75aefb2b02a91a0818c8ef2d5191075e280c4dbd01bda827cdd65f9957
+  data.tar.gz: d52b47712bd0d0d9705270e8c1487e2a1d797bcc52a46253b866e0fe4c6a1617
 SHA512:
-  metadata.gz: 613f0bce684a98834ddc99031b1dbe0cb4aa04448d8f88aa20dd1cf71c938d3539e0e26ec46a096373a83fc2c542f73d9163ca0e1be2428c3854a583f3e974da
-  data.tar.gz: 888271b35ed4a18bd776c8249ae5bc83ec51ec7930d1b58954e829da508ceb500fcf14e0340009a0410c2e009a5ffbf99109a5a22a447ca52b00982d722800e3
+  metadata.gz: ba7a127d408a2ab7ce745b0ad1d6d88eee710953ecceaa42a7880c6fb258a4b684cbc9f8bf11d36b1473bb99a55fd219a8fd434475f7352c238b1c2d03bdce9e
+  data.tar.gz: 2d99560d20e4d04a1b5c6abacba8579e0973bca2251fb402caa1a301e8a99317eed6a864892a47b8740a87a3861aeb6692791e97fc61c0a57e20d8b41727e930

data/.yardopts

@@ -3,6 +3,7 @@
 --charset UTF-8
 --markup markdown
 --readme README.md
+--asset assets
 --title "wxRuby3 API Documentation"
 --output-dir rdoc
 --protected

data/INSTALL.md

@@ -10,14 +10,14 @@ Below are installation instructions for Linux, Windows, and Mac (both AMD64 and
 
 The minimal requirements for installing any source based setup (gem, source package or Github clone) of wxRuby3 are:
 
-| Sofware                                       | Notes                                                                                                                                                                                                                                                             |
-|-----------------------------------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| Ruby                                          | A supported version of the Ruby interpreter needs to be installed.                                                                                                                                                                                                |
-| C++ compiler<br>(incl. dev tools like `make`) | On linux a recent version of the GNU C++ compiler (with c++-14 support) needs to be installed<br>On Windows the RubyInstaller MSYS2-Devkit needs to be installed<br>On MacOS XCode with commandline tools needs to be installed via `sudo xcode-select --install` |
-| Git version control toolkit                   |                                                                                                                                                                                                                                                                   |
-| SWIG >= 3.0.12                                | On MacOS install [Homebrew](https://brew.sh/) and than `brew install swig`                                                                                                                                                                                        |
-| Doxygen (>= 1.9.1, <= 1.9.6)                  | Doxygen > 1.9.6 has changes that cause problems with the wxWidgets doxygen files.<br>On MacOS: `brew tap mcorino/wxruby3` and than `brew install doxygen@1.9.6` (default brew recipe installs 1.9.7)                                                              |
-| wxWidgets (>= 3.2)                            | See [wxWidgets installation](#wxwidgets-installation)                                                                                                                                                                                                             |
+| Sofware                                       | Notes                                                                                                                                                                                                                                                                        |
+|-----------------------------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| Ruby                                          | A supported version of the Ruby interpreter needs to be installed.                                                                                                                                                                                                           |
+| C++ compiler<br>(incl. dev tools like `make`) | On linux a recent version of the GNU C++ compiler (with c++-14 support) needs to be installed<br>On Windows the RubyInstaller MSYS2-Devkit needs to be installed<br>On MacOS XCode with commandline tools needs to be installed via <code>sudo xcode-select --install</code> |
+| Git version control toolkit                   |                                                                                                                                                                                                                                                                              |
+| SWIG >= 3.0.12                                | On MacOS install Homebrew (https://brew.sh) and than <code>brew install swig</code>                                                                                                                                                                                          |
+| Doxygen (>= 1.9.1, <= 1.9.6)                  | Doxygen > 1.9.6 has changes that cause problems with the wxWidgets doxygen files.<br>On MacOS: <code>brew tap mcorino/wxruby3</code> and than `brew install doxygen@1.9.6` (default brew recipe installs 1.9.7)                                                              |
+| wxWidgets (>= 3.2)                            | See the <b>wxWidgets installation</b> section below.                                                                                                                                                                                                                         |
 
 The wxRuby3 build process requires `git` to clone a copy of the wxWidgets Github repository to extract the interface 
 specifications from.<br>
@@ -57,46 +57,41 @@ gem install wxruby3 -- WITH_WXWIN=1
 
 Also a wxWidgets installation (version 3.2 or later) is required for which there are multiple options.
 
-1. System installed wxWidgets version (including development package)<br>
-   <br>
+1. System installed wxWidgets version (including development package)<br/>
+   <br/>
    This is the default method used when installing the source gem without any options.<br>
    The wxRuby build procedure will determine the availability and version of wxWidgets by locating and calling
    the `wx-config` utility script. In case no (compatible) wxWidgets version is found installation ends with an error.<br>
    Please note that even with this method a copy of the wxWidgets project will be checked out from GitHUb as the wxRuby3
    build procedure requires access to the wxWidgets interface specification sources which are not normally part of any of 
-   the standard distribution packages.
-   
-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;On MacOS, you can install wxWidgets via [Homebrew](https://brew.sh/):
-
-```shell
+   the standard distribution packages.<br/> 
+   <br/>
+   On MacOS, you can install wxWidgets via [Homebrew](https://brew.sh/):
+   ```shell
    brew install wxwidgets
-```
-
-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Afterwards, you can install the Ruby gem and it will detect wxWidgets in the system automatically:
-
-```shell
+   ```
+   Afterwards, you can install the Ruby gem and it will detect wxWidgets in the system automatically:
+   ```shell
    gem install wxruby3
-```   
+   ```   
 
 2. User installed wxWidgets version<br>
    <br>
    In case the system being installed on does not provide (a compatible) wxWidgets version or a specific (possibly updated)
    wxWidgets version is required the source gem can be installed using a user installed version like this (where the 
    `WXWIN` path should provide the location where the wxWidgets binaries are installed under `<wxwin path>/bin`):<br>
-
-```shell
+   ```shell
    gem install wxruby3 -- WXWIN=/path/to/wx/install 
-```
+   ```
 
 3. Automatic installed, embedded, wxWidgets version<br>
    <br>
    This is the easiest method when the system being installed on does not provide (a compatible) wxWidgets version (and 
    no specific user defined version is required) and can be used by installing the source gem like this (which will
    cause automatic checkout and building of the latest stable wxWidgets release (>= 3.2) from GitHub:
-
-```shell
+   ```shell
    gem install wxruby3 -- WITH_WXWIN=1
-```
+   ```
 
 In case of option **2** it is also possible to do the doxygen XML generation as part of the wxWidgets user installation
 and use that for the gem installation. In that case the user is required to generate the XML interface specs using the
@@ -104,16 +99,27 @@ and use that for the gem installation. In that case the user is required to gene
 provided to the gem installation as follows:
 
 ```shell
-   gem install wxruby3 -- WXWIN=/path/to/wx/install WXXML=/path/to/wx/doxygen/xml
+gem install wxruby3 -- WXWIN=/path/to/wx/install WXXML=/path/to/wx/doxygen/xml
 ```
 
-Please also not that in case of option two the user is responsible to make sure the wxWidgets shared libraries can be
+Please also not that in case of option **2** the user is responsible to make sure the wxWidgets shared libraries can be
 found by the system's dynamic loader at runtime.
 
 > **NOTE:** Be patient when installing the source gem. Building wxRuby3 takes a while and when wxWidgets is included event more. 
 
 > **NOTE:** Be aware that for prerelease versions of the gem you should add the `--pre` argument to the `gem install` command. 
 
+### Bundled CLI
+
+Installing the wxRuby3 gem will also install the bundled `wxruby` CLI binary.
+
+Currently this binary can be used to run the bundled regression tests and access (run or copy) the bundled examples.
+Run the following command to see the options:
+
+```shell
+wxruby --help
+```
+
 ## Building from source
 
 Checkout the wxRuby3 sources from [GitHub](https://github.com/mcorino/wxRuby3) or download and unpack a release package.

data/README.md

@@ -96,11 +96,11 @@ of these products.
 
 Currently the following are fully supported:
 
-| Platform                                                                   | Ruby version(s) | wxWidgets version(s) |
-|----------------------------------------------------------------------------|-----------------| --- |
-| Windows 10 (tested)<br>(most likely also Windows 11)                       | Ruby >= 2.5<br>(RubyInstaller MSYS2-DevKit) | wxWidgets >= 3.2 |
-| Linux (tested; any AMD-64 distribution)<br>(most likely also i686 and ARM) | Ruby >= 2.5 | wxWidgets >= 3.2 |
-| MacOS >= 10.10 using Cocoa (tested on AMD-64 and ARM64 M2 Chip)            | Ruby >= 2.5 | wxWidgets >= 3.2 |
+| Platform                                                                   | Ruby version(s)                             | wxWidgets version(s) |
+|----------------------------------------------------------------------------|---------------------------------------------|----------------------|
+| Windows 10 (tested)<br>(most likely also Windows 11)                       | Ruby >= 2.5<br>(RubyInstaller MSYS2-DevKit) | wxWidgets >= 3.2     |
+| Linux (tested; any AMD-64 distribution)<br>(most likely also i686 and ARM) | Ruby >= 2.5                                 | wxWidgets >= 3.2     |
+| MacOS >= 10.10 using Cocoa (tested on AMD-64 and ARM64 M2 Chip)            | Ruby >= 2.5                                 | 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
@@ -118,14 +118,16 @@ Installing the binary gem version on Windows requires no additional software to
 version of the Ruby interpreter.<br>
 To install the source-only gem the following software is required:
 
-| Sofware                                       | Notes                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
-|-----------------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| Ruby                                          | A supported version of the Ruby interpreter needs to be installed.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
-| C++ compiler<br>(incl. dev tools like `make`) | On linux a recent version of the GNU C++ compiler (with c++-14 support) needs to be installed<br>On Windows the RubyInstaller MSYS2-Devkit needs to be installed<br>On MacOS XCode with commandline tools needs to be installed                                                                                                                                                                                                                                                                                                                                                                                                              |
-| Git version control toolkit                   |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
-| SWIG >= 3.0.12                                | On MacOS install [Homebrew](https://brew.sh/) and than `brew install swig`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
-| Doxygen (>= 1.9.1, <= 1.9.6)                  | Doxygen > 1.9.6 has changes that cause problems with the wxWidgets doxygen files.<br>On MacOS: `brew tap mcorino/wxruby3` and than `brew install doxygen@1.9.6` (default brew recipe installs 1.9.7)                                                                                                                                                                                                                                                                                                                                                                                                                                         |
-| wxWidgets >= 3.2 (*OPTIONAL*)                 | On Linux most distributions provide system installable (development) packages for wxWidgets providing a supported version. Alternatively you can fairly easily install your own preferred version manually (see the [wxWidgets](https://wxwidgets.org) project for details).<br>On Windows and MacOS the process is less straightforward (also here see the [wxWidgets](https://wxwidgets.org) project for details).<br>The wxRuby3 source-only gem can also be installed using a private local wxWidgets installation or an embedded installation (most likely preferred on Windows and MacOS). See [INSTALL](INSTALL.md) for more details. |    
+| Sofware                                       | Notes                                                                                                                                                                                                                           |
+|-----------------------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| Ruby                                          | A supported version of the Ruby interpreter needs to be installed.                                                                                                                                                              |
+| C++ compiler<br>(incl. dev tools like `make`) | On linux a recent version of the GNU C++ compiler (with c++-14 support) needs to be installed<br>On Windows the RubyInstaller MSYS2-Devkit needs to be installed<br>On MacOS XCode with commandline tools needs to be installed |
+| Git version control toolkit                   |                                                                                                                                                                                                                                 |
+| SWIG >= 3.0.12                                | On MacOS install with Homebrew                                                                                                                                                                                                  |
+| Doxygen (>= 1.9.1, <= 1.9.6)                  | Doxygen > 1.9.6 has changes that cause problems with the wxWidgets doxygen files.                                                                                                                                               |
+| wxWidgets >= 3.2 (*OPTIONAL*)                 | On Linux most distributions provide system installable (development) packages for wxWidgets providing a supported version.<br>Alternatively you can fairly easily install your own preferred version manually.                  |    
+
+See the [INSTALL](INSTALL.md) document for more details.
 
 In case the prerequisites above are met the (source-only or binary) gem can be installed executing the following command:
 
@@ -154,7 +156,9 @@ distribution comes with numerous samples which illustrate how to use
 many specific parts of the API. A good one to start with is the
 'minimal' sample, which provides an application skeleton. All the
 bundled samples are expected to work with current wxRuby3, although
-some use a more modern coding style than others.
+some use a more modern coding style than others. Use the bundled `wxruby`
+CLI to access the samples (see the section **Bundled CLI** in 
+the [INSTALL](INSTALL.md) document for more details).
 
 Complete (more or less) wxRuby API documentation should be part of any
 complete wxRuby3 build. This tends to focus on providing a reference
@@ -213,4 +217,9 @@ this doesn't help, please post your question using GitHub Issues.
 
 ### Is there another, more declarative way, for writing wxRuby3 desktop GUI applications?
 
-Yes. [Glimmer DSL for WX](https://github.com/AndyObtiva/glimmer-dsl-wx) enables software engineers to build GUI using wxruby3 following the Ruby way with the least amount of code possible. That is by offering a minimalistic declarative high-level DSL that maps visually to the way software engineers think about the GUI hierarchy in addition to adopting Rails' strategy of Convention over Configuration via smart defaults and automation of wxruby3 low-level details. You can check out the [Glimmer DSL for WX README "Coming From wxruby3" section](https://github.com/AndyObtiva/glimmer-dsl-wx#coming-from-wxruby3) for more information on how to translate wxruby3 apps to [Glimmer DSL for WX](https://github.com/AndyObtiva/glimmer-dsl-wx) syntax.
+Yes. [Glimmer DSL for WX](https://github.com/AndyObtiva/glimmer-dsl-wx) enables software engineers to build GUI 
+using wxruby3 following the Ruby way with the least amount of code possible. That is by offering a minimalistic 
+declarative high-level DSL that maps visually to the way software engineers think about the GUI hierarchy in addition 
+to adopting Rails' strategy of Convention over Configuration via smart defaults and automation of wxruby3 low-level 
+details. You can check out the [Glimmer DSL for WX README "Coming From wxruby3" section](https://github.com/AndyObtiva/glimmer-dsl-wx#coming-from-wxruby3) for more information on 
+how to translate wxruby3 apps to [Glimmer DSL for WX](https://github.com/AndyObtiva/glimmer-dsl-wx) syntax.

data/ext/wxruby3/include/wxRubyApp.h

@@ -0,0 +1,338 @@
+// Copyright (c) 2023 M.J.N. Corino, The Netherlands
+//
+// This software is released under the MIT license.
+
+#include <memory>
+
+/*
+ * WxRuby3 App class
+ */
+
+class wxRubyApp : public wxApp
+{
+private:
+  bool is_running_ = false;
+  VALUE self_ = Qnil;
+public:
+  static wxRubyApp* GetInstance () { return dynamic_cast<wxRubyApp*> (wxApp::GetInstance()); }
+
+  virtual ~wxRubyApp()
+  {
+#ifdef __WXTRACE__
+  std::wcout << "~wxRubyApp" << std::endl;
+#endif
+    // unlink
+    if (this->self_ != Qnil)
+    {
+      DATA_PTR(this->self_) = 0;
+    }
+    this->self_ = Qnil;
+  }
+
+  // special event handler for destruction of windows which is done
+  // automatically by wxWidgets. Tag the object as having been destroyed
+  // by WxWidgets.
+  void OnWindowDestroy(wxWindowDestroyEvent &event)
+  {
+    wxObject* wx_obj = event.GetEventObject();
+#ifdef __WXRB_DEBUG__
+    if (wxRuby_TraceLevel()>0)
+      std::wcout << "<= OnWindowDestroy [" << wx_obj << "]" << std::endl;
+#endif
+    GC_SetWindowDeleted((void *)wx_obj);
+    event.Skip();
+#ifdef __WXRB_DEBUG__
+    if (wxRuby_TraceLevel()>0)
+      std::wcout << "=> OnWindowDestroy [" << wx_obj << "]" << std::endl;
+#endif
+  }
+
+  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)
+  {
+
+#ifdef __WXRB_DEBUG__
+    if (wxRuby_TraceLevel()>0)
+      std::wcout << "=== Starting App GC mark phase" << std::endl;
+#endif
+
+    // If the App has ended, the ruby object will have been unlinked from
+    // the C++ one; this implies that all Windows have already been destroyed
+    // so there is no point trying to mark them, and doing so may cause
+    // errors.
+    if ( !wxRubyApp::GetInstance() || !wxRubyApp::GetInstance()->IsRunning() )
+    {
+#ifdef __WXRB_DEBUG__
+      if (wxRuby_TraceLevel()>0)
+        std::wcout << "=== App not started yet or has ended, skipping mark phase" << std::endl;
+#endif
+      return;
+    }
+
+    // Mark any active (tracked) log target
+    wxLog* curLog = wxLog::GetActiveTarget();
+    VALUE rb_cur_log = wxRuby_FindTracking(curLog);
+    if (!NIL_P(rb_cur_log))
+    {
+      rb_gc_mark(rb_cur_log);
+    }
+
+    // Mark evt handler procs associated with live windows - see
+    // 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);
+
+#ifdef __WXRB_DEBUG__
+    if (wxRuby_TraceLevel()>0)
+      std::wcout << "=== App GC mark phase completed" << std::endl;
+#endif
+  }
+
+  // This is the method run when main_loop is called in Ruby
+  // wxEntry calls the C++ App::OnInit method
+  int main_loop()
+  {
+    int rc = 0;
+
+    // There should ever only be only a single App instance running
+    if (rb_const_defined(mWxCore, rb_intern("THE_APP")))
+    {
+      rb_raise(rb_eRuntimeError, "There is already another App instance running");
+      return -1;
+    }
+
+    // Set self reference and global THE_APP constant
+    this->self_ = SWIG_RubyInstanceFor(this);
+    rb_define_const(mWxCore, "THE_APP", this->self_);
+    // Also cache the Ruby App reference on the stack here as after
+    // wxEntry returns the C++ App instance will have been destroyed
+    // and we cannot reference it (or it's members) anymore
+    VALUE the_app = this->self_;
+
+    this->Connect(wxEVT_DESTROY,
+          wxWindowDestroyEventHandler(wxRubyApp::OnWindowDestroy));
+
+#ifdef __WXRB_DEBUG__
+    if (wxRuby_TraceLevel()>0)
+      std::wcout << "Calling wxEntry, this=" << this << std::endl;
+#endif
+
+    // collect ruby app name and arguments array
+    VALUE rb_args = rb_get_argv();
+    int argc = 1 + RARRAY_LEN(rb_args);
+    std::unique_ptr<char*[]> argv_safe = std::make_unique<char*[]> (argc);
+    VALUE sval = rb_gv_get("$0");
+    argv_safe[0] = StringValuePtr(sval);
+    for (int i=0; i<RARRAY_LEN(rb_args) ;++i)
+    {
+      sval = rb_ary_entry(rb_args, i);
+      argv_safe[1+i] = StringValuePtr(sval);
+    }
+    // there is no need to copy the strings as we only need them until
+    // wxEntry returns
+
+#ifdef __WXMSW__
+    wxApp::m_nCmdShow = SW_NORMAL;
+#endif
+    rc = wxEntry(argc, argv_safe.get());
+
+    /*
+      At this point the C++ wxRubyApp instance has been destroyed so take care NOT to reference
+      it or any of it's members anymore but only unroll the callstack.
+     */
+
+#ifdef __WXRB_DEBUG__
+    if (wxRuby_TraceLevel()>0)
+      std::wcout << "returned from wxEntry..." << std::endl;
+#endif
+    rb_gc_start();
+#ifdef __WXRB_DEBUG__
+    if (wxRuby_TraceLevel()>0)
+      std::wcout << "survived gc" << std::endl;
+#endif
+
+    rb_const_remove(mWxCore, rb_intern("THE_APP"));
+
+    VALUE exc = rb_iv_get(the_app, "@exception");
+    if (!NIL_P(exc))
+    {
+      rb_exc_raise(exc);
+    }
+    return rc;
+  }
+
+  // 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
+  // be initialized any earlier than this without crashing
+  bool OnInit() override
+  {
+#ifdef __WXRB_DEBUG__
+    if (wxRuby_TraceLevel()>0)
+      std::wcout << "OnInit..." << std::endl;
+#endif
+
+    if (!wxApp::OnInit())
+      return false;
+
+    // Signal that we've started
+    this->is_running_ = true;
+    // Set up the GDI objects
+    Init_wxRubyStockObjects();
+    // Get the ruby representation of the App object, and call the
+    // ruby on_init method to set up the initial window state
+    bool ex_caught = false;
+    VALUE result  = wxRuby_Funcall(ex_caught, this->self_, rb_intern("on_ruby_init"), 0, 0);
+
+    if (ex_caught)
+    {
+#ifdef __WXRB_DEBUG__
+      wxRuby_PrintException(result);
+#endif
+      rb_iv_set(this->self_, "@exception", result);
+      result = Qfalse; // exit app
+    }
+
+    // If on_init return any (ruby) true value, signal to wxWidgets to
+    // enter the main event loop by returning true, else return false
+    // which will make wxWidgets exit.
+    if ( result == Qfalse || result == Qnil )
+    {
+      this->is_running_ = false;
+      return false;
+    }
+    else
+    {
+      return true;
+    }
+  }
+
+  int OnExit() override
+  {
+#ifdef __WXRB_DEBUG__
+    if (wxRuby_TraceLevel()>0)
+      std::wcout << "OnExit..." << std::endl;
+#endif
+
+    // Get the ruby representation of the App object, and call the
+    // ruby on_exit method (if any) for application level cleanup
+    ID on_exit_id = rb_intern("on_exit");
+    if (rb_funcall(this->self_, rb_intern("respond_to?"), 1, ID2SYM(on_exit_id)) == Qtrue)
+    {
+      bool ex_caught = false;
+      VALUE rc = wxRuby_Funcall(ex_caught, this->self_, on_exit_id, 0, 0);
+      if (ex_caught)
+      {
+#ifdef __WXRB_DEBUG__
+        wxRuby_PrintException(rc);
+#endif
+        rb_iv_set(this->self_, "@exception", rc);
+      }
+    }
+
+    // perform wxRuby cleanup
+    _wxRuby_Cleanup();
+
+    // execute base wxWidgets functionality
+    return this->wxApp::OnExit();
+  }
+
+  // actually implemented in ruby in classes/app.rb
+  virtual void OnAssertFailure(const wxChar *file, int line, const wxChar *func, const wxChar *cond, const wxChar *msg) override
+  {
+    if (rb_during_gc() || NIL_P(this->self_))
+    {
+      std::wcerr << file << "(" << line << "): ASSERT " << cond
+                 << (NIL_P(this->self_) ? " fired without THE_APP in " : " fired during GC phase in ")
+                 << func << "() with message [" << msg << "]" << std::endl;
+    }
+    else
+    {
+      VALUE obj0 = Qnil ;
+      VALUE obj1 = Qnil ;
+      VALUE obj2 = Qnil ;
+      VALUE obj3 = Qnil ;
+      VALUE obj4 = Qnil ;
+
+      obj0 = rb_str_new2((const char *)wxString(file).utf8_str());
+      obj1 = INT2NUM(line);
+      obj2 = rb_str_new2((const char *)wxString(func).utf8_str());
+      obj3 = rb_str_new2((const char *)wxString(cond).utf8_str());
+      obj4 = rb_str_new2((const char *)wxString(msg).utf8_str());
+      (void)wxRuby_Funcall(this->self_, rb_intern("on_assert_failure"), 5,obj0,obj1,obj2,obj3,obj4);
+    }
+  }
+
+  void _wxRuby_Cleanup()
+  {
+#ifdef __WXRB_DEBUG__
+    if (wxRuby_TraceLevel()>0)
+      std::wcout << "wxRuby_Cleanup..." << std::endl;
+#endif
+    // Note in a global variable that the App has ended, so that we
+    // can skip any GC marking later
+    this->is_running_ = false;
+
+    // if a Ruby implemented logger has been installed clean that up
+    // before we exit, otherwise let wxWidgets handle things
+    wxLog *oldlog = wxLog::GetActiveTarget();
+    if (wxRuby_FindTracking(oldlog) != Qnil)
+    {
+      oldlog = wxLog::SetActiveTarget(new wxLogStderr);
+    }
+    else
+    {
+      oldlog = 0;
+    }
+    SetTopWindow(0);
+    if ( oldlog )
+    {
+      SWIG_RubyUnlinkObjects(oldlog);
+      SWIG_RubyRemoveTracking(oldlog);
+      delete oldlog;
+    }
+  }
+};

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

@@ -0,0 +1,48 @@
+// Copyright (c) 2023 M.J.N. Corino, The Netherlands
+//
+// This software is released under the MIT license.
+
+/*
+ * WxRuby3 wxRubyClientData class
+ */
+
+#ifndef _WXRUBY_CLIENT_DATA_H
+#define _WXRUBY_CLIENT_DATA_H
+
+#include <wx/clntdata.h>
+
+class WXRUBY_EXPORT wxRubyClientData;
+
+WXRUBY_EXPORT void wxRuby_RegisterClientData(wxRubyClientData* pcd);
+WXRUBY_EXPORT void wxRuby_UnregisterClientData(wxRubyClientData* pcd);
+
+class WXRUBY_EXPORT wxRubyClientData : public wxClientData
+{
+public:
+  wxRubyClientData() : rb_data(Qnil) { }
+  wxRubyClientData (VALUE data) : rb_data(data) { wxRuby_RegisterClientData(this); }
+  virtual ~wxRubyClientData () { wxRuby_UnregisterClientData(this); }
+  VALUE GetData() const { return rb_data; }
+private:
+  VALUE rb_data;
+};
+
+class WXRUBY_EXPORT wxRubyUserData;
+
+WXRUBY_EXPORT void wxRuby_RegisterUserData(wxRubyUserData* pud);
+WXRUBY_EXPORT void wxRuby_UnregisterUserData(wxRubyUserData* pud);
+
+class WXRUBY_EXPORT wxRubyUserData : public wxObject
+{
+public:
+  wxRubyUserData() : rb_data(Qnil) { }
+  wxRubyUserData (VALUE data) : rb_data(data) { wxRuby_RegisterUserData(this); }
+  virtual ~wxRubyUserData () { wxRuby_UnregisterUserData(this); }
+  VALUE GetData() const { return rb_data; }
+private:
+  VALUE rb_data;
+
+  wxDECLARE_NO_COPY_CLASS(wxRubyUserData);
+};
+
+#endif /* _WXRUBY_CLIENT_DATA_H */

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

@@ -456,7 +456,7 @@ protected:
   }
 
 #ifdef wxHAS_LONG_LONG_T_DIFFERENT_FROM_LONG
-  virtual bool DoReadLongLong(const wxString& key, wxLongLong_t *pll) const
+  virtual bool DoReadLongLong(const wxString& key, wxLongLong_t *pll) const override
   {
     wxConfigPathChanger path(this, key);
 
@@ -487,7 +487,7 @@ protected:
   }
 #endif // wxHAS_LONG_LONG_T_DIFFERENT_FROM_LONG
 
-  virtual bool DoReadDouble(const wxString& key, double* val) const
+  virtual bool DoReadDouble(const wxString& key, double* val) const override
   {
     wxConfigPathChanger path(this, key);
 
@@ -517,7 +517,7 @@ protected:
     }
   }
 
-  virtual bool DoReadBool(const wxString& key, bool* val) const
+  virtual bool DoReadBool(const wxString& key, bool* val) const override
   {
     wxConfigPathChanger path(this, key);
 
@@ -637,7 +637,7 @@ protected:
   }
 
 #ifdef wxHAS_LONG_LONG_T_DIFFERENT_FROM_LONG
-  virtual bool DoWriteLongLong(const wxString& key, wxLongLong_t value)
+  virtual bool DoWriteLongLong(const wxString& key, wxLongLong_t value) override
   {
     wxConfigPathChanger     path(this, key);
     wxString                strName = path.Name();
@@ -675,7 +675,7 @@ protected:
   }
 #endif // wxHAS_LONG_LONG_T_DIFFERENT_FROM_LONG
 
-  virtual bool DoWriteDouble(const wxString& key, double value)
+  virtual bool DoWriteDouble(const wxString& key, double value) override
   {
     wxConfigPathChanger     path(this, key);
     wxString                strName = path.Name();
@@ -712,7 +712,7 @@ protected:
     return true;
   }
 
-  virtual bool DoWriteBool(const wxString& key, bool value)
+  virtual bool DoWriteBool(const wxString& key, bool value) override
   {
     wxConfigPathChanger     path(this, key);
     wxString                strName = path.Name();