wxruby3 0.9.3-x64-mingw-ucrt → 0.9.4-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/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).

data/lib/wx/doc/extra/15_persistence.md

@@ -0,0 +1,148 @@
+<!--
+# @markup markdown
+# @title 15. Persistence support
+-->
+
+# 15. Persistence support
+
+## Introduction
+
+wxRuby3 fully supports the wxWidgets persistence framework.
+
+This framework provides the means to persist window (and other object) states which can than be restored when
+re-creating these objects.
+
+The persistence framework depends on the configuration framework (see [here](14_config.md)).
+
+The persistence framework includes the following components:
+
+* {Wx::PersistenceManager} which all persistent objects register themselves with. This class handles actual saving 
+  and restoring of persistent data.
+* Persistent object adapters for persistent objects. These adapters provide a bridge between the associated class – 
+which has no special persistence support – and {Wx::PersistenceManager}. All Persistent object adapters need to derive 
+from {Wx::PersistentObject} (like {Wx::PersistentWindowBase} and it's derivatives).
+* The {Wx.create_persistent_object} and {Wx.persistent_register_and_restore} methods (mainly convenience methods for 
+wxWidgets compatibility).
+
+## Persistence manager
+
+By default a global singleton manager instance is available through {Wx::PersistenceManager.get} which will be used
+by all available persistent object adapters for saving/restoring state values.
+
+An alternate (possibly customized) manager instance can be installed through {Wx::PersistenceManager.set}.
+
+## Persistent object adapters
+
+All persistent object adapters must be derived from {Wx::PersistentObject}. This class provides common methods for
+saving and restoring state values connecting to the persistence manager for actual writing and reading.
+
+All windows/objects to be persisted need to be registered with the persistence manager. Creating the correct persistent
+object adapter instance for an object to persist is abstracted away in wxWidgets by using template methods allowing
+to simply only provide the object to persist instead of having to explicitly instantiate an adapter instance and provide
+both to the persistence manager (which is however still possible).
+
+wxRuby3 replaces this convenience interface (incompatible with Ruby) by a Ruby-fied approach which relies on Rubies 
+trusted *duck typing*.<br>
+In wxRuby3 any class supported by a specific persistent object adapter class should implement the method 
+`#create_persistent_object` which should return a unique adapter instance for the object instance to be persisted 
+like this:
+
+```ruby
+class MyPersistentObject < Wx::PersistentObject
+
+  # Save the object properties.
+  # The implementation of this method should use {Wx::PersistentObject#save_value}.
+  # @return [void]
+  def save
+    # ...
+  end
+
+  # Restore the object properties.
+  # The implementation of this method should use {Wx::PersistentObject#restore_value}.
+  # @return [Boolean]
+  def restore
+    # ...
+  end
+
+  # Returns the string uniquely identifying the objects supported by this adapter.
+  # This method has default implementations in any of the built-in derived adapter classes.
+  # @return [String]
+  def get_kind
+    'MyObject'
+  end
+
+  # Returns the string uniquely identifying the object we're associated with among all the other objects of the same type.
+  # This method has a default implementation in Wx::PersistentWindowBase returning the window name.
+  # @return [String]
+  def get_name
+    'object_1'
+  end
+
+end
+
+class MyObject
+  
+  # ...
+  
+  def create_persistent_object
+    MyPersistentObject.new(self)
+  end
+  
+  # ...
+  
+end
+```
+
+## Persistent windows
+
+A number of classes provide built-in support for persistence of a number of windows or controls:
+
+* {Wx::PersistentTLW} supports top level windows (including {Wx::Frame} and {Wx::Dialog}).
+* {Wx::PersistentBookCtrl} supports the book controls {Wx::Notebook}, {Wx::Listbook}, {Wx::Toolbook} and {Wx::Choicebook}.
+* {Wx::PersistentTreeBookCtrl} supports {Wx::Treebook}
+
+All persistent window adapters are derived from {Wx::PersistentWindowBase}. This class makes sure that any window 
+registered for persisting gets automatically saved when the window is destroyed. Intermittently explicit saving still
+remains possible of course.
+
+User defined persistent window adapters can be derived from this class or any of the built-in derivatives to support
+otherwise unsupported or custom windows/controls like this:
+
+```ruby
+class PersistentButton < Wx::PersistentWindowBase
+
+  def get_kind
+    'Button'
+  end
+    
+  def save
+    save_value('w', get.size.width)
+    save_value('h', get.size.height)
+    save_value('label', get.label)
+    save_value('my_custom_value', get.my_custom_value)
+  end
+    
+  def restore
+    get.size = [Integer(restore_value('w')), Integer(restore_value('h'))]
+    get.label = restore_value('label')
+    get.my_custom_value = Float(restore_value('my_custom_value'))
+    true
+  end
+
+end
+
+class MyButton < Wx::Button
+
+  def initialize(parent=nil, name)
+    super(parent, label: '', name: name)
+    @my_custom_value = ''
+  end
+
+  attr_accessor :my_custom_value
+
+  def create_persistent_object
+    PersistentButton.new(self)
+  end
+
+end
+```

data/lib/wx/doc/gen/aui/aui_manager_event.rb

@@ -35,7 +35,7 @@ module Wx::AUI
   class AuiManagerEvent < Event
   
     # Constructor.
-    # @param type [Wx::StaticLine::EventType] 
+    # @param type [Wx::Notebook::EventType] 
     # @return [Wx::AUI::AuiManagerEvent]
     def initialize(type=Wx::EVT_NULL) end
     

data/lib/wx/doc/gen/aui/aui_notebook_event.rb

@@ -181,7 +181,7 @@ module Wx::AUI
   class AuiNotebookEvent < BookCtrlEvent
   
     # Constructor.
-    # @param command_type [Wx::StaticLine::EventType] 
+    # @param command_type [Wx::Notebook::EventType] 
     # @param win_id [Integer] 
     # @return [Wx::AUI::AuiNotebookEvent]
     def initialize(command_type=Wx::EVT_NULL, win_id=0) end

data/lib/wx/doc/gen/aui/aui_tool_bar_event.rb

@@ -139,7 +139,7 @@ module Wx::AUI
   class AuiToolBarEvent < NotifyEvent
   
     # @overload initialize(commandType=Wx::EVT_NULL, winId=0)
-    #   @param commandType [Wx::StaticLine::EventType] 
+    #   @param commandType [Wx::Notebook::EventType] 
     #   @param winId [Integer] 
     #   @return [Wx::AUI::AuiToolBarEvent]
     # @overload initialize(c)