wxruby3 0.9.2 → 0.9.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 94bf5f5a3d4107e4a77c02971756de87b044c3d9edfbedd0b0aa0fe3e95e6ae7
-  data.tar.gz: 83d78771dde19401cbb0e5f915c7eb86903bf76357f1a1d0be4d10edf1f0d4a7
+  metadata.gz: 59f48a6760484b863b4f3255bf866ecbd18faa5c0488fd40c6379bda58747299
+  data.tar.gz: f131b88dab9c1994d98ae2fede1021308a539d298b6743c67a62ffc679748f0e
 SHA512:
-  metadata.gz: f1ac191dac02b350104d6336d38af941126056f30da9d2bffa12d480592216f0059f7cc1e22fa4020898a26faeffbc64d71df09eefd2b3329956c5e70a97b23b
-  data.tar.gz: '08d86fdf568ef0b67d76c670ccd108194342c7c0d97710419f7e98e0c852d8a863540aa3c320052237c27adf1c37f4d92a7c927fb827fcbbc5d05a73789e40e1'
+  metadata.gz: 9f5a04f23e4978c856f79a8d2393d2cb08e2c4ce971fb915123cefb5ea2ee92a6fca38b3c7ccbc456c1e07480158dae5191635a9861cdcb5d7919be5f3c9e169
+  data.tar.gz: ee935202f9fb3ef7af42da60b4311725c584485548f35c55b6f12ae4fa2b410740fc117b718134052a7aeb915ba7d2140cd096bc3f20a2ab1a1b5e30e82234b5

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/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

@@ -53,6 +53,7 @@ static int wxrb_CountConfig(VALUE key, VALUE value, VALUE rbCounter)
 }
 
 static VALUE g_cConfigBase;
+static VALUE g_cConfigWx;
 static VALUE g_cConfig;
 
 /*
@@ -88,12 +89,18 @@ public:
 
   virtual ~wxRbHashConfig()
   {
-    DATA_PTR(m_cfgInstance) = 0; // make sure it never get's deleted twice
+    if (!NIL_P(m_cfgInstance))
+    {
+      DATA_PTR(m_cfgInstance) = 0; // make sure it never get's deleted twice
+    }
   }
 
-  // Get wrapped Ruby ConfigBase instance
+  // Get wrapped Ruby Config instance
   VALUE GetRubyConfig() const { return m_cfgInstance; }
 
+  // Reset wrapped Ruby Config instance
+  void ResetRubyConfig() { m_cfgInstance = Qnil; }
+
   // implement inherited pure virtual functions
   virtual void SetPath(const wxString& strPath) override { DoSetPath(strPath, true /* create missing components */); }
   virtual const wxString& GetPath() const override { return m_strPath; }
@@ -806,7 +813,7 @@ private:
 
   void SetRootPath()
   {
-    m_strPath.Empty();
+    m_strPath.Clear();
     m_cfgGroup = m_cfgHash;
     m_cfgGroupKeys = Qnil;
   }
@@ -815,7 +822,7 @@ private:
   // if path doesn't exist and createMissingComponents == false
   bool DoSetPath(const wxString& strPath, bool createMissingComponents)
   {
-    if ( strPath.empty() )
+    if ( strPath.IsEmpty() || strPath == cfgSepStr)
     {
         SetRootPath();
         return true;
@@ -913,7 +920,8 @@ static const char * __iv_Config_data = "@data";
 
 WXRUBY_EXPORT bool wxRuby_IsRubyConfig(VALUE rbConfig)
 {
-  return rb_obj_is_kind_of(rbConfig, g_cConfig) == Qtrue;
+  return rb_obj_is_kind_of(rbConfig, g_cConfig) == Qtrue ||
+    rb_obj_is_kind_of(rbConfig, g_cConfigWx) == Qtrue;
 }
 
 // Wrap a Ruby hash for input type mapping
@@ -933,6 +941,12 @@ WXRUBY_EXPORT wxConfigBase* wxRuby_Ruby2ConfigBase(VALUE rbConfig)
     // return wrapper
     return config;
   }
+  else if (rb_obj_is_kind_of(rbConfig, g_cConfigWx) == Qtrue)
+  {
+    wxConfigBase* cfg;
+    Data_Get_Struct(rbConfig, wxConfigBase, cfg);
+    return cfg;
+  }
   return nullptr;
 }
 
@@ -946,6 +960,10 @@ WXRUBY_EXPORT VALUE wxRuby_ConfigBase2Ruby(wxConfigBase* config)
     {
       return hsh_config->GetRubyConfig();
     }
+    else
+    {
+      return Data_Wrap_Struct(g_cConfigWx, 0, 0, config);
+    }
   }
   return Qnil;
 }

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

@@ -0,0 +1,79 @@
+// Copyright (c) 2023 M.J.N. Corino, The Netherlands
+//
+// This software is released under the MIT license.
+
+/*
+ * WxRuby3 persistence classes
+ */
+
+#ifndef _WXRUBY_PERSISTENCE_HASH_H
+#define _WXRUBY_PERSISTENCE_HASH_H
+
+#include <wx/persist.h>
+#include <wx/config.h>
+
+#include <map>
+
+/*
+  This class serves as a base for any Ruby defined persistence manager in order to provide
+  customized save and restore methods for Ruby values but also as a replacement for the
+  default global persistence manager instance.
+ */
+class WxRubyPersistenceManager : public wxPersistenceManager
+{
+private:
+  typedef std::map<VALUE, VALUE> rb_object_to_rb_po_map_t;
+  rb_object_to_rb_po_map_t rb_object_po_map_;
+
+public:
+  WxRubyPersistenceManager() : wxPersistenceManager() {}
+
+  bool SaveRubyValue(const wxPersistentObject& who, const wxString& name, VALUE value);
+
+  VALUE RestoreRubyValue(const wxPersistentObject& who, const wxString& name);
+
+
+  bool DoSaveRubyValue(const wxPersistentObject& who, const wxString& name, VALUE value);
+
+  VALUE DoRestoreRubyValue(const wxPersistentObject& who, const wxString& name);
+
+  void RegisterRbPO(VALUE rb_obj, VALUE rb_po)
+  {
+    rb_object_po_map_[rb_obj] = rb_po;
+  }
+
+  VALUE FindRbPO(VALUE rb_obj)
+  {
+    VALUE rb_po = Qnil;
+    if (rb_object_po_map_.count(rb_obj) > 0)
+    {
+      rb_po = rb_object_po_map_[rb_obj];
+    }
+    return rb_po;
+  }
+
+  VALUE UnregisterRbPO(VALUE rb_obj)
+  {
+    VALUE rb_po = Qnil;
+    if (rb_object_po_map_.count(rb_obj) > 0)
+    {
+      rb_po = rb_object_po_map_[rb_obj];
+      rb_object_po_map_.erase(rb_obj);
+    }
+    return rb_po;
+  }
+
+  void GC_markPO();
+
+  static void UnregisterPersistentObject(VALUE rb_obj);
+};
+
+class WxRubyPersistentObject : public wxPersistentObject
+{
+public:
+  virtual ~WxRubyPersistentObject();
+protected:
+  WxRubyPersistentObject(VALUE rb_obj);
+};
+
+#endif /* _WXRUBY_PERSISTENCE_HASH_H */

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

@@ -0,0 +1,39 @@
+// Copyright (c) 2023 M.J.N. Corino, The Netherlands
+//
+// This software is released under the MIT license.
+
+/*
+ * WxRuby3 wxRubyValidator class
+ */
+
+#ifndef _WXRUBY_VALIDATOR_H
+#define _WXRUBY_VALIDATOR_H
+
+#include "wxruby-ValidatorBinding.h"
+
+class WXRUBY_EXPORT wxRubyValidator : public wxValidator, public wxRubyValidatorBinding
+{
+public:
+  wxRubyValidator ();
+  wxRubyValidator (const wxRubyValidator&);
+  virtual ~wxRubyValidator ();
+
+  virtual wxObject* Clone() const override;
+
+  virtual void SetWindow(wxWindow *win) override;
+
+  virtual bool TransferFromWindow () override;
+  virtual bool TransferToWindow () override;
+
+protected:
+  static WxRuby_ID do_transfer_from_window_id;
+  static WxRuby_ID do_transfer_to_window_id;
+  static WxRuby_ID clone_id;
+
+  virtual VALUE DoTransferFromWindow();
+  virtual bool DoTransferToWindow(VALUE data);
+
+  virtual VALUE get_self() override;
+};
+
+#endif /* _WXRUBY_VALIDATOR_HASH_H */

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

@@ -0,0 +1,64 @@
+// Copyright (c) 2023 M.J.N. Corino, The Netherlands
+//
+// This software is released under the MIT license.
+
+/*
+ * WxRuby3 wxRubyValidatorBinding class
+ */
+
+#ifndef _WXRUBY_VALIDATOR_BINDING_H
+#define _WXRUBY_VALIDATOR_BINDING_H
+
+class WXRUBY_EXPORT wxRubyValidatorBinding
+{
+public:
+  wxRubyValidatorBinding ()
+    : self_(Qnil)
+    , on_transfer_from_win_proc_(Qnil)
+    , on_transfer_to_win_proc_(Qnil)
+  {}
+
+  void SetOnTransferFromWindow(VALUE proc)
+  {
+    this->on_transfer_from_win_proc_ = proc;
+  }
+  void SetOnTransferToWindow(VALUE proc)
+  {
+    this->on_transfer_to_win_proc_ = proc;
+  }
+
+  VALUE DoOnTransferToWindow();
+  bool DoOnTransferFromWindow(VALUE data);
+
+  bool OnTransferFromWindow(VALUE data);
+  VALUE OnTransferToWindow();
+
+  void GC_Mark()
+  {
+    rb_gc_mark(this->on_transfer_from_win_proc_);
+    rb_gc_mark(this->on_transfer_to_win_proc_);
+  }
+
+protected:
+  static WxRuby_ID do_on_transfer_from_window_id;
+  static WxRuby_ID do_on_transfer_to_window_id;
+  static WxRuby_ID call_id;
+
+  wxRubyValidatorBinding (const wxRubyValidatorBinding& vb)
+    : self_(Qnil)
+    , on_transfer_from_win_proc_(vb.on_transfer_from_win_proc_)
+    , on_transfer_to_win_proc_(vb.on_transfer_to_win_proc_)
+  {}
+
+  void CopyBindings(const wxRubyValidatorBinding* val_bind);
+
+  virtual VALUE get_self() = 0;
+
+  VALUE self_;
+
+private:
+  VALUE on_transfer_from_win_proc_;
+  VALUE on_transfer_to_win_proc_;
+};
+
+#endif /* #define _WXRUBY_VALIDATOR_BINDING_H */

data/ext/wxruby3/swig/custom/director.swg

@@ -195,6 +195,14 @@ namespace Swig {
     }
   };
 
+  /* wxRuby customization */
+  class WXRUBY_EXPORT DirectorRubyException : public DirectorException
+  {
+  public:
+    DirectorRubyException(VALUE error, VALUE rcvr, ID fn_id);
+
+  };
+
   /* Simple thread abstraction for pthreads on win32 */
 #ifdef __THREAD__
 # define __PTHREAD__

data/ext/wxruby3/swig/mark_free_impl.i

@@ -309,37 +309,4 @@ WXRUBY_EXPORT void GC_mark_wxFrame(void *ptr)
     std::wcout << "> GC_mark_wxFrame : " << ptr << std::endl;
 #endif
 }
-
-// wxRuby must preserve ruby objects attached as the ClientData of
-// command events that have been user-defined in ruby. Some of the
-// standard wxWidgets CommandEvent classes (which have a constant event
-// id less than wxEVT_USER_FIRST, from wx/event.h) also use ClientData
-// for their own purposes, and this must not be marked as the data is
-// not a ruby object, and will thus crash.
-WXRUBY_EXPORT void GC_mark_wxEvent(void *ptr)
-{
-#ifdef __WXRB_DEBUG__
-  if (wxRuby_TraceLevel()>1)
-    std::wcout << "> GC_mark_wxEvent : " << ptr << std::endl;
-#endif
-
-  if ( ! ptr ) return;
-  wxEvent* wx_event = (wxEvent*)ptr;
-#ifdef __WXRB_DEBUG__
-  if (wxRuby_TraceLevel()>2)
-    std::wcout << "* GC_mark_wxEvent(" << ptr << ":{" << wx_event->GetEventType() << "})" << std::endl;
-#endif
-  if ( wx_event->GetEventType() > wxEVT_USER_FIRST &&
-       wx_event->IsCommandEvent() )
-	{
-	  wxCommandEvent* wx_cm_event = (wxCommandEvent*)ptr;
-	  VALUE rb_client_data = (VALUE)wx_cm_event->GetClientData();
-	  rb_gc_mark(rb_client_data);
-	}
-
-#ifdef __WXRB_DEBUG__
-  if (wxRuby_TraceLevel()>1)
-    std::wcout << "< GC_mark_wxEvent : " <<  ptr << std::endl;
-#endif
-}
 %}

data/ext/wxruby3/swig/memory_management.i

@@ -106,6 +106,12 @@ GC_NEVER(kls);
 %define GC_MANAGE_AS_UNTRACKED(kls)
 %enddef
 
+// Strategy for objects that are GC marked through customized, tailored, mechanisms outside
+// of the standard SWIG object tracking option.
+// The different naming is mostly to allow doc gen to properly recognize these objects.
+%define GC_MANAGE_AS_MARKED(kls)
+%enddef
+
 // Sizers attached to windows are automatically destroyed by wxWidgets,
 // so they should not be deleted.
 //

data/lib/wx/core/bitmap_combobox.rb

@@ -8,32 +8,28 @@
 
 module Wx
 
-  class BitmapCombobox < Wx::ComboBox
-
-    # We need to cache client data in Ruby variables as we cannot access items
-    # during the GC mark phase as for some platforms (WXMSW at least) that would
-    # involve calling methods that would break in that phase.
+  class BitmapComboBox < Wx::ComboBox
 
     wx_append = instance_method :append
-    define_method :append do |item, bitmap=Wx::NULL_BITMAP, data=nil|
-      itm_pos = if data
-                  wx_append.bind(self).call(item, bitmap, data)
-                else
-                  wx_append.bind(self).call(item, bitmap)
-                end
-      client_data_store.insert(itm_pos, data)
-      itm_pos
+    define_method :append do |item, *rest| #bitmap=Wx::NULL_BITMAP, data=nil|
+      if ::Array === item
+        super(item, *rest)
+      elsif rest.empty? || Wx::Bitmap === rest.first
+        wx_append.bind(self).call(item, *rest)
+      else
+        super(item, *rest)
+      end
     end
 
     wx_insert = instance_method :insert
-    define_method :insert do |item, bitmap, pos, data=nil|
-      itm_pos = if data
-                  wx_insert.bind(self).call(item, bitmap, pos, data)
-                else
-                  wx_insert.bind(self).call(item, bitmap, pos)
-                end
-      client_data_store.insert(itm_pos, data)
-      itm_pos
+    define_method :insert do |item, *rest| # bitmap, pos, data=nil|
+      if ::Array === item
+        super(item, *rest)
+      elsif rest.empty? || Wx::Bitmap === rest.first
+        wx_insert.bind(self).call(item, *rest)
+      else
+        super(item, *rest)
+      end
     end
 
   end

data/lib/wx/core/book_ctrl_base.rb

@@ -0,0 +1,16 @@
+# Copyright (c) 2023 M.J.N. Corino, The Netherlands
+#
+# This software is released under the MIT license.
+
+module Wx
+
+  class BookCtrlBase
+
+    # create PersistentObject for toplevel windows (incl. Dialog and Frame)
+    def create_persistent_object
+      PersistentBookCtrl.new(self)
+    end
+
+  end
+
+end