wxruby3 0.9.3-x64-mingw-ucrt → 0.9.5-x64-mingw-ucrt

data/lib/wx/core/notebook.rb

@@ -8,15 +8,17 @@
 
 # Displays a set of pages in parallel using tabs
 
-class Wx::Notebook
-  # Convenience method for iterating pages
-  def each_page
-    if block_given?
-      0.upto(get_page_count - 1) do | i |
-        yield get_page(i)
+module Wx
+  class Notebook
+    # Convenience method for iterating pages
+    def each_page
+      if block_given?
+        0.upto(get_page_count - 1) do | i |
+          yield get_page(i)
+        end
+      else
+        ::Enumerator.new { |y| each_page { |pg| y << pg } }
       end
-    else
-      ::Enumerator.new { |y| each_page { |pg| y << pg } }
     end
   end
 end

data/lib/wx/core/peristent_object.rb

@@ -0,0 +1,15 @@
+# Copyright (c) 2023 M.J.N. Corino, The Netherlands
+#
+# This software is released under the MIT license.
+
+module Wx
+
+  class PersistentObject
+
+    # make these protected
+    protected :save_value
+    protected :restore_value
+
+  end
+
+end

data/lib/wx/core/persistence_manager.rb

@@ -0,0 +1,39 @@
+# Copyright (c) 2023 M.J.N. Corino, The Netherlands
+#
+# This software is released under the MIT license.
+
+module Wx
+
+  # Function used to create the correct persistent adapter for the given object.
+  def self.create_persistent_object(obj)
+    obj.create_persistent_object
+  end
+
+  # A shorter synonym for {Wx::PersistenceManager#register_and_restore}.
+  def self.persistent_register_and_restore(obj, name=nil)
+    obj.name = name if name && !name.empty?
+    PersistenceManager.get.register_and_restore(obj)
+  end
+
+  class PersistenceManager
+
+    class << self
+
+      # Cache the global instance to keep it safe from GC
+
+      wx_get = instance_method :get
+      define_method :get do
+        @the_manager ||= wx_get.bind(self).call
+      end
+
+      wx_set = instance_method :set
+      define_method :set do |pman|
+        wx_set.bind(self).call(pman)
+        @the_manager = pman
+      end
+
+    end
+
+  end
+
+end

data/lib/wx/core/persistent_window.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 PersistentWindowBase < PersistentObject
+
+    alias :get :get_object
+
+  end
+
+  # class alias
+  PersistentWindow = PersistentWindowBase
+
+end

data/lib/wx/core/top_level_window.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 TopLevelWindow
+
+    # create PersistentObject for toplevel windows (incl. Dialog and Frame)
+    def create_persistent_object
+      PersistentTLW.new(self)
+    end
+
+  end
+
+end

data/lib/wx/core/treebook.rb

@@ -0,0 +1,18 @@
+# Copyright (c) 2023 M.J.N. Corino, The Netherlands
+#
+# This software is released under the MIT license.
+
+require_relative './book_ctrl_base'
+
+module Wx
+
+  class Treebook
+
+    # Creates PersistentObject for this treebook control instance.
+    def create_persistent_object
+      PersistentTreeBookCtrl.new(self)
+    end
+
+  end
+
+end

data/lib/wx/core.rb

@@ -49,6 +49,10 @@ end
 ::Wx.include(WxRubyStyleAccessors)
 
 ::Wx.include((defined?(::WX_GLOBAL_CONSTANTS) && ::WX_GLOBAL_CONSTANTS) ? WxGlobalConstants : WxEnumConstants)
+# Provide support for finding enumerator constants for nested enums in Wx::Object derived classes without
+# full scoping. This does not cover non Wx::Object derived classes with nested enums in the Wx hierarchy
+# but there should not be too many of those.
+::Wx::Object.include(WxEnumConstants)
 
 # Load in syntax sweeteners
 require 'wx/keyword_defs'

data/lib/wx/doc/book_ctrl_base.rb

@@ -0,0 +1,19 @@
+# :stopdoc:
+# Copyright (c) 2023 M.J.N. Corino, The Netherlands
+#
+# This software is released under the MIT license.
+# :startdoc:
+
+
+module Wx
+
+  class BookCtrlBase < Control
+
+    # Creates PersistentObject for this book control instance (incl. ChoiceBook, ListBook and NoteBook).
+    # @see Wx.create_persistent_object
+    # @return [Wx::PersistentBookCtrl]
+    def create_persistent_object; end
+
+  end
+
+end

data/lib/wx/doc/comboctrl.rb

@@ -7,11 +7,136 @@
 
 module Wx
 
-  class OwnerDrawnComboBox < ComboCtrl
+  # In order to use a custom popup with {Wx::ComboCtrl}, a class must include {Wx::ComboPopup}.
+  #
+  # For more information on how to use it, see {Wx::ComboCtrl Setting Custom Popup for Wx::ComboCtrl}.
+  module ComboPopup
 
-    alias :get_item_data :get_client_object
+    # Returns pointer to the associated parent {Wx::ComboCtrl}.
+    # @return [Wx::ComboCtrl]
+    def get_combo_ctrl; end
 
-    alias :set_item_data :set_client_object
+    # The including class must implement this to initialize its internal variables.
+    #
+    # This method is called immediately after construction finishes. m_combo member variable has been initialized before the call.
+    # @return [void]
+    def init; end
+
+    # The including class may implement this to return true if it wants to delay call to {Wx::ComboPopup#create} until the popup is shown for the first time.
+    #
+    # It is more efficient, but on the other hand it is often more convenient to have the control created immediately.
+    #
+    # <div class="wxrb-remark">
+    # <b>Remark:</b>
+    # <p>Base implementation returns false.
+    # </p>
+    # </div>
+    # @return [Boolean]
+    def lazy_create; end
+
+    # The including class must implement this to create the popup control.
+    #
+    # true if the call succeeded, false otherwise.
+    # @param parent [Wx::Window]
+    # @return [Boolean]
+    def create(parent) end
+
+    # You only need to implement this member function if you create your popup class in non-standard way.
+    #
+    # The default implementation can handle both multiple-inherited popup control (as seen in {Wx::ComboCtrl} samples) and one allocated separately in heap.
+    # If you do completely re-implement this function, make sure it calls Destroy() for the popup control and also deletes this object (usually as the last thing).
+    # @return [void]
+    def destroy_popup; end
+
+    # Implement to customize matching of value string to an item container entry.
+    #
+    # <div class="wxrb-remark">
+    # <b>Remark:</b>
+    # <p>Default implementation always return true and does not alter trueItem.
+    # </p>
+    # </div>
+    # @param item [String]  String entered, usually by user or from SetValue() call.
+    # @param trueItem [Boolean] if true the true item string should be returned in case matching but different
+    # @return [Boolean, String] Returns true if a match is found or false if not. If trueItem == true and item matches an entry, but the entry's string representation is not exactly the same (case mismatch, for example), then the true item string should be returned as the match result.
+    def find_item(item, trueItem=false) end
+
+    # The including class may implement this to return adjusted size for the popup control, according to the variables given.
+    #
+    # <div class="wxrb-remark">
+    # <b>Remark:</b>
+    # <p>This function is called each time popup is about to be shown.
+    # </p>
+    # </div>
+    # @param minWidth [Integer]  Preferred minimum width.
+    # @param prefHeight [Integer]  Preferred height. May be -1 to indicate no preference.
+    # @param maxHeight [Integer]  Max height for window, as limited by screen size.
+    # @return [Wx::Size]
+    def get_adjusted_size(minWidth, prefHeight, maxHeight) end
+
+    # The including class must implement this to return pointer to the associated control created in {Wx::ComboPopup#create}.
+    # @return [Wx::Window]
+    def get_control; end
+
+    # The including class must implement this to receive string value changes from {Wx::ComboCtrl}.
+    # @param value [String]
+    # @return [void]
+    def set_string_value(value) end
+
+    # The including class must implement this to return string representation of the value.
+    # @return [String]
+    def get_string_value; end
+
+    # The including class may implement this to do something when the parent {Wx::ComboCtrl} gets double-clicked.
+    # @return [void]
+    def on_combo_double_click; end
+
+    # The including class may implement this to receive key down events from the parent {Wx::ComboCtrl}.
+    #
+    # Events not handled should be skipped, as usual.
+    # @param event [Wx::KeyEvent]
+    # @return [void]
+    def on_combo_key_event(event) end
+
+    # The including class may implement this to receive char events from the parent {Wx::ComboCtrl}.
+    #
+    # Events not handled should be skipped, as usual.
+    # @param event [Wx::KeyEvent]
+    # @return [void]
+    def on_combo_char_event(event) end
+
+    # The including class may implement this to do special processing when popup is hidden.
+    # @return [void]
+    def on_dismiss; end
+
+    # The including class may implement this to do special processing when popup is shown.
+    # @return [void]
+    def on_popup; end
+
+    # The including class may implement this to paint the parent {Wx::ComboCtrl}.
+    # This is called to custom paint in the combo control itself (ie. not the popup).
+    #
+    # Default implementation draws value as string.
+    # @param dc [Wx::DC]
+    # @param rect [Wx::Rect]
+    # @return [void]
+    def paint_combo_control(dc, rect) end
+
+  end
+
+  # A Ruby interface class for default comboctrl popup classes used by {Wx::OwnerDrawnComboBox} and
+  # {Wx::RichTextStyleListBox}.
+  #
+  # If no custom popup control has been installed with {Wx::ComboCtrl#SetPopupControl} an instance of this
+  # class will be returned when {Wx::ComboCtrl#GetPopupControl} is called for either of the widgets mentioned
+  # above.
+  # <div class="wxrb-remark">
+  # <b>Remark:</b>
+  # <p>This is an abstract class that cannot be derived from.
+  # </p>
+  # </div>
+  class ComboPopupWx
+
+    include ComboPopup
 
   end
 

data/lib/wx/doc/config.rb

@@ -14,53 +14,35 @@ module Wx
   # as in C++.
   class ConfigBase
 
-    # Create a new config object and sets it as the current one unless a global Ruby config was already created/installed.
+    # Create a new config instance and sets it as the current one unless a global config was already created/installed. If
+    # forced_create is true any existing global config will be replaced by a new config instance.
     # This function will create the most appropriate implementation of Wx::ConfigBase available for the current platform.
-    # In Ruby this means that a Wx::Config instance will created and appropriately wrapped in C++.
-    # @return [Wx::Config] the current configuration object
-    def self.create; end
+    # If use_hash_config is true this means that a Wx::Config instance will created and appropriately wrapped in C++
+    # otherwise the default C++ config for the current/active platform will be used.
+    # @param [Boolean] forced_create specifies to force replacing any existing global config if true
+    # @param [Boolean] use_hash_config specifies to create a Ruby Hash based config when required if true
+    # @return [Wx::ConfigBase] the current configuration object
+    def self.create(forced_create=false, use_hash_config: false) end
 
     # Sets the config object as the current one, returns the previous current object (both the parameter and returned
     # value may be nil).
-    # @param [Wx::Config,nil] config the config object to install
-    # @return [Wx::Config] the previous current configuration object
+    # @param [Wx::ConfigBase,nil] config the config object to install
+    # @return [Wx::ConfigBase] the previous current configuration object
     def self.set(config) end
 
     # Get the current config object.
-    # If there is no current object and create_on_demand is true, this creates one.
-    # @param [Boolean] create_on_demand specifies whether to create a configuration object is none has been created/installed before
-    # @return [Wx::Config,nil] the current configuration object
+    # If there is no current object and create_on_demand is true, this creates a default config instance appropriate for
+    # the current/active platform (registry based for Windows and file based otherwise).
+    # @param [Boolean] create_on_demand specifies whether to create a configuration object if none has been created/installed before
+    # @return [Wx::ConfigBase,nil] the current configuration object
     def self.get(create_on_demand=true) end
 
-  end
-
-  # Configuration class for wxRuby which stores it's settings in a (possibly nested) Hash.
-  # This way configurations can be easily persisted using any commonly used Ruby methods like
-  # YAML or JSON files.
-  #
-  # Wx::Config supports Boolean (true or false), Integer, Float and String values and nested groups
-  # (essentially nested hashes). Any entry values set will be sanitized to match the supported types, i.e.
-  # if the value matches a supported type the value is accepted unaltered otherwise Integer (`to_int`), Float (`to_f`)
-  # or String (`to_s`) coercion are applied (in that order). Hash values are installed as nested groups.
-  #
-  # Like the C++ wxConfigBase derivatives Wx::Config supports arbitrary access using path strings which support
-  # absolute paths ('/xxxx') and relative paths ('xxx/xxx', '../xxx', './xxxx'). Relative segments can also be
-  # embedded in the path strings ('/aaa/bbb/../ccc').
-  class Config < ConfigBase
-
     # Config path separator
     SEPARATOR = '/'
 
     # Common configuration access methods for either the root object or any nested group objects.
     module Interface
 
-      # Iterate all settings at the current object (no recursion).
-      # Passes key/value pairs to the given block or returns an Enumerator is no block given.
-      # @yieldparam [String] key setting key
-      # @yieldparam [Boolean,String,Integer,Float,Wx::Config::Group] value setting value
-      # @return [Object,Enumerator] either the last result of the executed block or an enumerator if no block given
-      def each(&block) end
-
       # Iterate all value entries at the current object (no recursion).
       # Passes key/value pairs to the given block or returns an Enumerator is no block given.
       # @yieldparam [String] key entry key
@@ -79,13 +61,13 @@ module Wx
       # any nested groups (if recurse is true)
       # @param [Boolean] recurse
       # @return [Integer] count
-      def number_of_entries(recurse: false) end
+      def number_of_entries(recurse=false) end
 
       # Returns the total number of group entries at the current object only (if recurse is false) or including
       # any nested groups (if recurse is true)
       # @param [Boolean] recurse
       # @return [Integer] count
-      def number_of_groups(recurse: false) end
+      def number_of_groups(recurse=false) end
 
       # Returns if a value entry exists matching the given path string.
       # Path strings can be absolute (starting with {SEPARATOR}) or relative to the current object and can have
@@ -114,10 +96,10 @@ module Wx
       # @return [Boolean,String,Integer,Float,Wx::Config::Group,nil] value entry value
       def set(key, val) end
 
-      # Removes the entry at the current object identified by `key` if it exists and returns it's value.
-      # @param [String] key entry key
+      # Removes the entry identified by `path_str` if it exists and returns it's value.
+      # @param [String] path_str entry path
       # @return [Boolean,String,Integer,Float,Hash,nil] entry value
-      def delete(key) end
+      def delete(path_str) end
 
       # Changes key for the entry at the current object identified by `old_key` to `new_key` if it exists.
       # @param [String] old_key current entry key
@@ -126,7 +108,17 @@ module Wx
       def rename(old_key, new_key) end
 
       # Returns a value for an entry from the configuration identified by `path_str`.
-      # Allows arbitrary access though the entire configuration using absolute or relative paths.
+      # Provides arbitrary access though the entire configuration using absolute or relative paths.
+      # Supports coercing configuration values to a specified output type (Integer,Float,String,TrueClass,FalseClass).
+      # By default returns un-coerced value.
+      # Raises exception if incompatible coercion is specified.
+      # @param [String] path_str
+      # @param [Class,Proc,nil] output output type (or converter proc) to convert to (with)
+      # @return [Boolean,String,Integer,Float,Wx::Config::Group,nil] value entry value
+      def read(path_str, output=nil) end
+
+      # Returns a value for an entry from the configuration identified by `path_str`.
+      # Provides arbitrary access though the entire configuration using absolute or relative paths.
       # @param [String] path_str
       # @return [Boolean,String,Integer,Float,Wx::Config::Group,nil] value entry value
       def [](path_str) end
@@ -137,7 +129,8 @@ module Wx
       # @param [String] path_str
       # @param [Boolean,String,Integer,Float,Hash,nil] val entry value
       # @return [Boolean,String,Integer,Float,Wx::Config::Group,nil] value entry value
-      def []=(path_str, val) end
+      def write(path_str, val) end
+      alias :[]= :write
 
       # Returns the path string for the current configuration object.
       # @return [String]
@@ -166,25 +159,92 @@ module Wx
 
     end
 
+  end
+
+  # This is an abstract class wrapping the default C++ Config class for the active platform
+  # (on Windows this would be `wxRegConfig` and `wxFileConfig` otherwise).
+  #
+  # Unless {Wx::ConfigBase.create} or {Wx::ConfigBase.set} has been called this is what will be
+  # returned by {Wx::ConfigBase.get}.
+  class ConfigWx < ConfigBase
+
+    class Group
+
+      include ConfigBase::Interface
+
+    end
+
+    include ConfigBase::Interface
+
+    # Deletes all configuration content and returns true if successful.
+    # Also deletes any persisted storage (files or registry entries).
+    # @return [Boolean]
+    def clear; end
+
+    # Replaces the configuration content with the content of the provided Hash.
+    # @param [Hash] hash content to replace configuration
+    # @return [self]
+    def replace(hash) end
+
+    # Returns true if we are expanding environment variables in string values, false otherwise.
+    # @return [Boolean]
+    def is_expanding_env_vars; end
+    alias :expanding_env_vars? :is_expanding_env_vars
+
+    # Determine whether we wish to expand environment variables in string values.
+    # @param [Boolean] flag enables expanding environment variables if true, disables otherwise
+    def set_expand_env_vars(flag) end
+    alias :expand_env_vars :set_expand_env_vars
+
+  end
+
+  # Configuration class for wxRuby which stores it's settings in a (possibly nested) Hash.
+  # This way configurations can be easily persisted using any commonly used Ruby methods like
+  # YAML or JSON files.
+  #
+  # Wx::Config supports Boolean (true or false), Integer, Float and String values and nested groups
+  # (essentially nested hashes). Any entry values set will be sanitized to match the supported types, i.e.
+  # if the value matches a supported type the value is accepted unaltered otherwise Integer (`to_int`), Float (`to_f`)
+  # or String (`to_s`) coercion are applied (in that order). Hash values are installed as nested groups.
+  #
+  # Like the C++ wxConfigBase derivatives Wx::Config supports arbitrary access using path strings which support
+  # absolute paths ('/xxxx') and relative paths ('xxx/xxx', '../xxx', './xxxx'). Relative segments can also be
+  # embedded in the path strings ('/aaa/bbb/../ccc').
+  class Config < ConfigBase
+
     class Group
 
-      include Interface
+      include ConfigBase::Interface
 
     end
 
-    include Interface
+    include ConfigBase::Interface
 
     # Constructor.
     # @param [Hash] hash optional Hash initializing configuration object
     # @return [Wx::Config]
     def initialize(hash = nil)end
 
+    # Deletes all configuration content and returns if successful.
+    # @return [true]
+    def clear; end
+
     # Replaces the configuration content with the content of the provided Hash.
     # Values will be sanitized (see {Wx::Config}).
     # @param [Hash] hash content to replace configuration
     # @return [self]
     def replace(hash) end
 
+    # Returns true if we are expanding environment variables in string values, false otherwise.
+    # @return [Boolean]
+    def is_expanding_env_vars; end
+    alias :expanding_env_vars? :is_expanding_env_vars
+
+    # Determine whether we wish to expand environment variables in string values.
+    # @param [Boolean] flag enables expanding environment variables if true, disables otherwise
+    def set_expand_env_vars(flag) end
+    alias :expand_env_vars :set_expand_env_vars
+
   end
 
 end

data/lib/wx/doc/extra/14_config.md

@@ -0,0 +1,101 @@
+<!--
+# @markup markdown
+# @title 14. Configuration support
+-->
+
+# 14. Configuration support
+
+## Introduction
+
+wxRuby3 fully supports the wxWidgets config classes providing a Ruby-fied interface.
+
+The config classes provide a way to store some application configuration information providing features
+that make them very useful for storing all kinds of small to medium volumes of hierarchically-organized, 
+heterogeneous data.
+In wxWidgets these were especially designed for storing application configuration information and intended to be 
+mostly limited to that. That meant the information to be stored was intended to be:
+
+* Typed, i.e. strings, booleans or numbers for the moment. You cannot store binary data, for example.
+* Small. For instance, it is not recommended to use the Windows registry (which is the default storage medium on 
+  that platform) for amounts of data more than a couple of kilobytes.
+* Not performance critical, neither from speed nor from a memory consumption point of view.
+
+As you will see wxRuby3 extends the support in this area and provides means to forego a lot of these restrictions.
+
+The config classes also are intended to abstract away a lot of platform differences. In this area wxRuby3 extends the
+support also.
+
+## Default configuration support
+
+When the default, global, config instance is used (by using {Wx::ConfigBase.get} with default argument) this will be 
+a platform specific instance. On Windows platforms a Windows registry based implementation is used and on other 
+platforms a text format configuration file.
+
+wxRuby3 provides a single wrapper class for these with {Wx::ConfigWx}. This is an abstract class that cannot be 
+instantiated in Ruby which provides a common, Ruby-fied interface supported by all config classes in wxRuby3.
+
+While wxWidgets does a decent job of abstracting platform differences it is in no way perfect in this area. With the
+text format configuration files for example the stored values loose all type information since everything is stored
+as strings. This also differs from the registry based implementation where some type information is not lost but some
+(like boolean types) is.
+This is not a problem when accessing information for which the structure and types are exactly known as the config
+classes offer type specific readers (as well as writers) which coerce values to their expected types but may offer 
+nasty surprises when more reflectively accessing data of which the exact typing and structure is not known.
+
+In Ruby where we more or less expect to have common API-s that can return or accept any type of object needing to be
+type specific is awkward. wxRuby3 works around this as much as possible for the {Wx::ConfigWx} wrapper class but also
+provides an alternative config class integrated with the wxWidgets framework that does not suffer from these restrictions.
+
+## Enhanced Ruby configuration support
+
+Instead of the default, platform specific, config classes it is also possible to use a custom wxRuby3 extension providing
+a config class which is implemented in pure Ruby and integrated in the wxWidgets configuration framework.
+To use an instance of this class as the global config instance the {Wx::ConfigBase.create} should be called at application
+initialization time with it's `:use_hash_config` keyword argument set to `true` (and possibly, to be sure, it's 
+`forced_create` argument set to `true` also). This would create an instance of {Wx::Config} and install that as the global config instance (if no other instance was
+yet installed or, overruling that condition, if `forced_create` was set to `true`).<br>
+Alternatively a {Wx::Config} (or derivative) instance could be explicitly instantiated in code and assigned as global 
+instance with {Wx::ConfigBase.set}.
+
+As the keyword argument indicates {Wx::Config} is a Ruby `Hash` based config class implementation. 
+
+Value objects are stored Ruby-style as-is into it's internal hash table (maintaining full type information) and are also 
+retrieved as-is by default (to maintain compatibility with the {Wx::ConfigWx} wrapper type coercion options are provided). 
+Grouping is based of nested `Hash` instances.
+
+Because of the `Hash` based implementation and lack of (the need for) type coercion the {Wx::Config} class does have **any**
+restrictions of the type of data stored. The only possible type restrictions to enforce may come from usage contexts:
+
+* In case of value entries shared with wxWidgets framework code (like for example entries save by the persistence 
+framework; see [here](15_persistence.md)) value types should be restricted to those supported by the wxWidget platform
+specific classes and correspond to what the framework code expects.
+* In case of the need to save/restore the configuration data to/from persistent storage which imposes type restrictions these 
+should be applied.
+
+With {Wx::Config} it would be perfectly alright to store arrays or any kind of arbitrary object (only be aware that `Hash`
+instances will always be expected to provide configuration structure by default) as long as these do not conflict with
+expectations of framework code or storage mechanisms.
+
+With the standard Ruby YAML and JSON serialization support this also provides improved platform independent configuration 
+persistence options with full type information maintainability. 
+
+## Differences between default and enhanced configuration support
+
+The major difference is, as described above, the absence of type restrictions in the enhanced Ruby config class {Wx::Config}.
+
+Another difference is that {Wx::Config} will not automatically create missing groups or entries on reading. This will only
+happen when writing configuration values.
+
+A last difference is that the default support is by default backed up by persistent storage (windows registry or file) and
+the wxRuby enhanced support only provides in-memory storage (`Hash` instance) by default. +
+Persisting configuration data from {Wx::Config} will require coding customized storage and retrieval operations (which is
+trivial using standard YAML or JSON support).  
+
+## Differences between wxWidgets config interface and wxRuby
+
+In wxRuby there is no option to provide a default value argument when reading values. The reasoning is that Ruby itself
+provides more than enough options to elegantly provide for defaults with statement options like `var ||= default` or
+`var = get('something') || default`.
+
+As a consequence wxRuby also does not support recording defaults on read operations (and also does not provide the
+corresponding option setter/getter in the interface).