wxruby3 0.9.2-x64-mingw-ucrt → 0.9.3-x64-mingw-ucrt

data/lib/wx/doc/event.rb

@@ -27,4 +27,16 @@ module Wx
 
   end
 
+  class CommandEvent < Event
+
+    alias :set_client_data :set_client_object
+
+    alias :client_data= :set_client_object
+
+    alias :get_client_data :get_client_object
+
+    alias :client_data :get_client_object
+
+  end
+
 end

data/lib/wx/doc/extra/12_client_data.md

@@ -0,0 +1,89 @@
+<!--
+# @markup markdown
+# @title 12. Client/User data with wxRuby
+-->
+
+# 12. Client/User data with wxRuby
+
+## Introduction
+
+The wxWidgets library has widespread support for attaching arbitrary client (or user) data to GUI elements like
+windows (all event handlers actually), window items, sizer items etc.
+To cater to various C++ use cases in most instances this support covers both specific wxWidgets defined types (like
+wxClientData and wxObject instances) and untyped data pointers (represented as `void *`) with subtle but essential
+differences.
+
+wxRuby implements a fully compatible version of this support.    
+
+## Everything is an Object
+
+As Ruby does not do untyped data (everything is an Object), and having two different options is confusing anyway, 
+wxRuby provides only a single option and more or less unifies the interface across the entire library.
+In Ruby anywhere the original wxWidgets library supports some type of client (or user) data attachment wxRuby will 
+support the attachment of any arbitrary Ruby `Object` by either the method `#set_client_object` (where C++ supports 
+`SetClientData` and `SetClientObject`) or `#set_user_data` (where C++ supports `SetUserData`). Data retrieval
+is supported by complementary `#get_client_object` or `#get_user_data` methods in all cases.
+Wherever C++ supports `SetClientObject` wxRuby also provides the method aliases `#set_client_data` and `#get_client_data`.
+
+Another difference with C++ is that for typed client data in wxWidgets developers could leverage object destruction as 
+callback trigger (through the implementation of virtual destructors) to handle any required 'unlinking' logic. This
+obviously does not apply to untyped data (one of the 'subtle' differences).
+As Ruby does not provide any usable object destruction hooks this does not work there.
+Ruby however has 'Duck-typing' which is what wxRuby uses to provide support for a unlinking callback 'hook' for attached
+client data.
+
+> Any attached Ruby Object implementing (responding to) the method `#client_data_unlinked` will have that method called after the 
+> attached object has been detached from the element it was attached to (either because of data replacement or element 
+> deletion).
+
+Regard the following example.
+
+```ruby
+    frame = Wx::Frame.new(nil, Wx::ID_ANY)
+    
+    # attach a hash with user data  
+    frame.set_client_data({ text: 'A string', float: 3.14 })
+    
+    # ... do something with frame
+    
+    # replace the user data
+    frame.set_client_data([1,2,3,4])
+
+    # ... do something else with frame
+```
+
+In this case standard Ruby object are attached. After attachment the object can be retrieved using a call to `get_client_data`
+anywhere access to the frame instance is available.
+
+Using a specially derived (or adapted) object a developer can handle specific logic after the object has been unlinked 
+like in this example:
+
+```ruby
+    # define a user data class
+    class MyUserData
+      def initialize(payload)
+        @payload = payload
+      end
+      attr_reader :payload
+      
+      def client_data_unlinked
+        # handle some logic
+      end
+    end
+
+    # ...
+
+    # attach data to some window
+    win.set_client_data(MyUserData.new(some_payload_data)) 
+
+    # ...
+    
+    # reset user data for some reason (will call MyUserData#client_data_unlinked after replacement)
+    win.set_client_data(nil)
+```
+
+# CommandEvent data
+
+wxRuby also fully supports the propagation of attached client data to Wx::CommandEvent objects (see
+{Wx::CommandEvent#get_client_object} and {Wx::CommandEvent#set_client_object}).
+As mentioned above wxRuby provides the method aliases `#set_client_data` and `#get_client_data` here also. 

data/lib/wx/doc/extra/13_validators.md

@@ -0,0 +1,139 @@
+<!--
+# @markup markdown
+# @title 13. Validators and data binding
+-->
+
+# 13. Validators and data binding
+
+## Introduction
+
+wxRuby fully supports validator classes offering input validation and/or data binding and/or event filtering. 
+
+## Validation
+
+The base Wx::Validator class defines the method {Wx::Validator#validate} which is called when validation of the
+value or content of the associated window is required.
+
+The implementation of this method should (somehow) retrieve the value of the associated window and validate that
+value, returning `true` if valid or `false` otherwise. The default implementation always returns `false`.
+
+An example would be:
+
+```ruby
+# define custom validator
+class MyTextValidator < Wx::Validator
+
+  def validate(_parent)
+    txt = get_window.value
+    # validate that the control text starts with a capital if not empty
+    txt.empty? || (?A..?Z).include?(txt[0])
+  end
+
+end
+
+# ...
+
+# assign custom validator to text control
+text = Wx::TextCtrl.new(parent, MY_TEXT_ID)
+text.set_validator(MyTextValidator.new)
+```
+
+The derived, specialized, validator classes {Wx::TextValidator}, {Wx::IntegerValidator}, {Wx::IntegerValidator} and 
+{Wx::FloatValidator} all have implementations that can be configured through specific options and do not 
+normally require an override to be defined.
+
+Examples of using the standard validators would be:
+
+```ruby
+text = Wx::TextCtrl.new(parent, MY_TEXT_ID)
+
+# accept only hexadecimal characters
+text.set_validator(Wx::TextValidator.new(Wx::TextValidatorStyle::FILTER_XDIGITS))
+
+# or only numbers between -20 and 20
+text.set_validator(Wx::IntegerValidator.new(-20, 20))
+```
+
+## Event filtering
+
+All validator classes are event handlers and can have event handling routines defined (see 
+[Event Handling](05_event-handling.md)).
+When processing events the core implementation will allow any validator associated with a window to handle an event
+before the associated window itself thereby allowing it to filter events (see {Wx::EvtHandler#process_event} for more 
+details).
+
+The standard specialized validators use this functionality to filter entry of allowable characters (by handling 
+Wx::EVT_CHAR events).
+
+## Data binding
+
+Data binding concerns the transfer of a validator's associated window's value to or from a user definable storage (a 
+variable, memory cache entry, persistent storage ...).
+
+To integrate with the core C++ implementation but allow for Ruby specific differences the scheme implemented for this
+differs somewhat (in naming and functionality) from the original wxWidgets interface.
+
+The responsibilities of the standard wxRuby interface for handling validator data binding is distributed over 2 base 
+methods and a mixin module.  
+
+- The protected {Wx::Validator#do_transfer_from_window} and {Wx::Validator#do_transfer_to_window} methods are 
+  responsible for collecting and transferring data from/to the associated window (possibly applying conversions).<br>
+  <br>
+  These methods have default implementations in all of the derived validator classes and should not be overridden for
+  specializations of these as they will be ignored.<br>
+  Overriding these methods is necessary to implement data binding for any user defined specialization of the base 
+  {Wx::Validator} class.<br>
+  <br>
+- The methods the {Wx::Validator::Binding} mixin module provide the means to store data after collection from or retrieve data 
+  before transfer to the associated window.<br>
+  <br>
+  The methods {Wx::Validator::Binding#on_transfer_from_window} and {Wx::Validator::Binding#on_transfer_to_window} provide
+  the means to specify user defined binding handlers for storing the data transferred from the associated window or retrieving the
+  data to transfer to the associated window. Like with event handling the handlers can be specified using a `String` or
+  `Symbol`, a `Proc` or a `Method`.<br>
+  <br>
+  The methods {Wx::Validator::Binding#do_on_transfer_from_window} and {Wx::Validator::Binding#do_on_transfer_to_window} by
+  default call the binding handlers if defined.
+  These methods can be overridden to create derived validator classes with dedicated data binding functionality like 
+  with {Wx::GenericValidator}.
+
+An example of a custom validator providing data binding would be:
+
+```ruby
+class MyTextValidator < Wx::Validator
+
+  def do_transfer_from_window
+    get_window.get_value
+  end
+
+  def do_transfer_to_window(val)
+    get_window.set_value(val)
+    true
+  end
+  
+end
+
+# ...
+
+# use custom validator
+@data = nil # attribute to store data
+text.set_validator(MyTextValidator.new)
+text.get_validator.on_transfer_to_window { @data }
+text.get_validator.on_transfer_from_window { |v| @data = v }
+```
+
+All derived, specialized, validators implement a dedicated value cache which can be accessed through the `#value` attribute
+accessor. Through this accessor the data collected from the associated window can get retrieved or the data to be transferred
+to the associated window set.
+With these classes it is therefor not necessary to define binding handlers. Defining binding handlers can however still be 
+useful to implement a custom, persistent, storage solution.
+
+### Wx::GenericValidator
+
+The {Wx::GenericValidator} class provides an extendable standard implementation for data binding in combination with a 
+large collection of controls (see class documentation).
+The implementation provides a standard accessor {Wx::GenericValidator#value} to get the data value collected
+from the associated window or set the data to transfer to the associated window.
+
+To add support for any control unsupported by the standard implementation the method {Wx::GenericValidator.define_handler}
+is provided (see documentation for an example).

data/lib/wx/doc/gdi_common.rb

@@ -61,8 +61,12 @@ module Wx
 
     alias :get_x :get_width
     alias :x :get_width
+    alias :set_x :set_width
+    alias :x= :set_width
     alias :get_y :get_height
     alias :y :get_height
+    alias :set_y :set_height
+    alias :y= :set_height
 
     # Set this size to the given size's width,height values
     # @param [Wx::Size] sz

data/lib/wx/doc/gen/about_dialog_info.rb

@@ -7,6 +7,7 @@
 module Wx
 
   # This function shows the standard about dialog containing the information specified in info.
+  # 
   # If the current platform has a native about dialog which is capable of showing all the fields in info, the native dialog is used, otherwise the function falls back to the generic wxWidgets version of the dialog, i.e. does the same thing as {generic_about_box}.
   # Here is an example of how this function may be used:
   # ```ruby
@@ -28,6 +29,7 @@ module Wx
   def self.about_box(info, parent=nil) end
   
   # This function does the same thing as {about_box} except that it always uses the generic wxWidgets version of the dialog instead of the native one.
+  # 
   # This is mainly useful if you need to customize the dialog by e.g. adding custom controls to it (customizing the native dialog is not currently supported).
   # See the Dialogs Sample for an example of about dialog customization.
   # @see Wx::AboutDialogInfo
@@ -37,6 +39,7 @@ module Wx
   def self.generic_about_box(info, parent=nil) end
   
   # {Wx::AboutDialogInfo} contains information shown in the standard About dialog displayed by the {about_box} function.
+  # 
   # This class contains the general information about the program, such as its name, version, copyright and so on, as well as lists of the program developers, documentation writers, artists and translators. The simple properties from the former group are represented as a string with the exception of the program icon and the program web site, while the lists from the latter group are stored as {Wx::ArrayString} and can be either set entirely at once using {Wx::AboutDialogInfo#set_developers} and similar functions or built one by one using {Wx::AboutDialogInfo#add_developer} etc.
   # Please also notice that while all the main platforms have the native implementation of the about dialog, they are often more limited than the generic version provided by wxWidgets and so the generic version is used if {Wx::AboutDialogInfo} has any fields not supported by the native version. Currently GTK+ version supports all the possible fields natively but MSW and Mac versions don't support URLs, licence text nor custom icons in the about dialog and if either of those is used, {about_box} will automatically use the generic version so you should avoid specifying these fields to achieve more native look and feel.
   # 
@@ -70,6 +73,7 @@ module Wx
     
     # Adds an artist name to be shown in the program credits.
     # 
+    # 
     # @see Wx::AboutDialogInfo#set_artists 
     # @param artist [String] 
     # @return [void]
@@ -77,6 +81,7 @@ module Wx
     
     # Adds a developer name to be shown in the program credits.
     # 
+    # 
     # @see Wx::AboutDialogInfo#set_developers 
     # @param developer [String] 
     # @return [void]
@@ -84,12 +89,14 @@ module Wx
     
     # Adds a documentation writer name to be shown in the program credits.
     # 
+    # 
     # @see Wx::AboutDialogInfo#set_doc_writers 
     # @param docwriter [String] 
     # @return [void]
     def add_doc_writer(docwriter) end
     
     # Adds a translator name to be shown in the program credits.
+    # 
     # Notice that if no translator names are specified explicitly, {about_box} will try to use the translation of the string <code>translator-credits</code> from the currently used message catalog  this can be used to show just the name of the translator of the program in the current language.
     # @see Wx::AboutDialogInfo#set_translators 
     # @param translator [String] 
@@ -97,6 +104,7 @@ module Wx
     def add_translator(translator) end
     
     # Get the name of the program.
+    # 
     # Name of the program
     # @see Wx::AboutDialogInfo#set_name 
     # @return [String]
@@ -105,12 +113,14 @@ module Wx
     
     # Returns true if a description string has been specified.
     # 
+    # 
     # @see Wx::AboutDialogInfo#get_description 
     # @return [Boolean]
     def has_description; end
     alias_method :has_description?, :has_description
     
     # Get the description string.
+    # 
     # The description string, free-form.
     # @return [Wx::String]
     def get_description; end
@@ -118,12 +128,14 @@ module Wx
     
     # Returns true if a copyright string has been specified.
     # 
+    # 
     # @see Wx::AboutDialogInfo#get_copyright 
     # @return [Boolean]
     def has_copyright; end
     alias_method :has_copyright?, :has_copyright
     
     # Get the copyright string.
+    # 
     # The copyright string
     # @return [Wx::String]
     def get_copyright; end
@@ -131,6 +143,7 @@ module Wx
     
     # Sets the list of artists to be shown in the program credits.
     # 
+    # 
     # @see Wx::AboutDialogInfo#add_artist 
     # @param artists [Array<String>] 
     # @return [void]
@@ -138,6 +151,7 @@ module Wx
     alias_method :artists=, :set_artists
     
     # Set the short string containing the program copyright information.
+    # 
     # Notice that any occurrences of <code>"(C)"</code> in copyright will be replaced by the copyright symbol (circled C) automatically, which means that you can avoid using this symbol in the program source code which can be problematic,
     # @param copyright [String] 
     # @return [void]
@@ -152,6 +166,7 @@ module Wx
     
     # Set the list of developers of the program.
     # 
+    # 
     # @see Wx::AboutDialogInfo#add_developer 
     # @param developers [Array<String>] 
     # @return [void]
@@ -160,6 +175,7 @@ module Wx
     
     # Set the list of documentation writers.
     # 
+    # 
     # @see Wx::AboutDialogInfo#add_doc_writer 
     # @param docwriters [Array<String>] 
     # @return [void]
@@ -177,6 +193,7 @@ module Wx
     alias_method :icon, :get_icon
     
     # Set the icon to be shown in the dialog.
+    # 
     # By default the icon of the main frame will be shown if the native about dialog supports custom icons. If it doesn't but a valid icon is specified using this method, the generic about dialog is used instead so you should avoid calling this function for maximally native look and feel.
     # @param icon [Wx::Icon] 
     # @return [void]
@@ -190,12 +207,14 @@ module Wx
     
     # Returns the licence string.
     # 
+    # 
     # @see Wx::AboutDialogInfo#set_licence 
     # @return [Wx::String]
     def get_licence; end
     alias_method :licence, :get_licence
     
     # Set the long, multiline string containing the text of the program licence.
+    # 
     # Only GTK+ version supports showing the licence text in the native about dialog currently so the generic version will be used under all the other platforms if this method is called. To preserve the native look and feel it is advised that you do not call this method but provide a separate menu item in the <code>"Help"</code> menu for displaying the text of your program licence.
     # @param licence [String] 
     # @return [void]
@@ -209,6 +228,7 @@ module Wx
     alias_method :license=, :set_license
     
     # Set the name of the program.
+    # 
     # If this method is not called, the string returned by {Wx::App::GetAppName} will be shown in the dialog.
     # @param name [String] 
     # @return [void]
@@ -216,6 +236,7 @@ module Wx
     alias_method :name=, :set_name
     
     # Set the list of translators.
+    # 
     # Please see {Wx::AboutDialogInfo#add_translator} for additional discussion.
     # @param translators [Array<String>] 
     # @return [void]
@@ -223,6 +244,7 @@ module Wx
     alias_method :translators=, :set_translators
     
     # Set the version of the program.
+    # 
     # The word "version" shouldn't be included in version. Example version values: "1.2" and "RC2". In about dialogs with more space set aside for version information, longVersion is used. Example longVersion values: "Version 1.2" and "Release Candidate 2". If version is non-empty but longVersion is empty, a long version is constructed automatically, using version (by simply prepending "Version " to version).
     # The generic about dialog and native GTK+ dialog use version only, as a suffix to the program name. The native MSW and macOS about dialogs use the long version.
     # @param version [String] 
@@ -233,6 +255,7 @@ module Wx
     
     # Return the short version string.
     # 
+    # 
     # @see Wx::AboutDialogInfo#set_version 
     # @return [Wx::String]
     def get_version; end
@@ -240,6 +263,7 @@ module Wx
     
     # Return the long version string if set.
     # 
+    # 
     # @see Wx::AboutDialogInfo#set_version 
     # @return [Wx::String]
     def get_long_version; end
@@ -261,6 +285,7 @@ module Wx
     alias_method :web_site_description, :get_web_site_description
     
     # Set the web site for the program and its description (which defaults to url itself if empty).
+    # 
     # Please notice that only GTK+ version currently supports showing the link in the native about dialog so if this method is called, the generic version will be used under all the other platforms.
     # @param url [String] 
     # @param desc [String] 

data/lib/wx/doc/gen/accelerator.rb

@@ -44,6 +44,7 @@ module Wx
   NULL_ACCELERATOR_TABLE = nil
   
   # An object used by an application wishing to create an accelerator table (see {Wx::AcceleratorTable}).
+  # 
   # Category:  Data Structures
   # @see Wx::AcceleratorTable
   # @see  Wx::Window#set_accelerator_table 
@@ -99,17 +100,20 @@ module Wx
     alias_method :ok?, :is_ok
     
     # Returns a textual representation of this accelerator.
+    # 
     # The returned string is of the form <code>[Alt+][Ctrl+][RawCtrl+][Shift+]Key</code> where the modifier keys are present only if the corresponding flag is set.
     # @return [String]
     def to_string; end
     
     # Returns a textual representation of this accelerator which is appropriate for saving in configuration files.
+    # 
     # Unlike the string returned by {Wx::AcceleratorEntry#to_string}, this one is never translated so, while it's not suitable for showing to the user, it can be used to uniquely identify the accelerator independently of the user language.
     # The returned string can still be parsed by {Wx::AcceleratorEntry#from_string}.
     # @return [String]
     def to_raw_string; end
     
     # Parses the given string and sets the accelerator accordingly.
+    # 
     # true if the given string correctly initialized this object (i.e. if {Wx::AcceleratorEntry#is_ok} returns true after this call)
     # @param str [String]  This string may be either in the same format as returned by {Wx::AcceleratorEntry#to_string}, i.e. contain the accelerator itself only, or have the format of a full menu item text with i.e. <code>Label TAB Accelerator</code>. In the latter case, the part of the string before the TAB is ignored. Notice that the latter format is only supported for the compatibility with the previous wxWidgets versions and the new code should pass only the accelerator string itself to this function.
     # @return [Boolean]
@@ -122,6 +126,7 @@ module Wx
   end # AcceleratorEntry
   
   # An accelerator table allows the application to specify a table of keyboard shortcuts for menu or button commands.
+  # 
   # The object {Wx::NULL_ACCELERATOR_TABLE} is defined to be a table with no data, and is the initial accelerator table for a window.
   # Example:
   # ```ruby
@@ -138,7 +143,7 @@ module Wx
   # <b>Remark:</b>
   # <p>An accelerator takes precedence over normal processing and can be a convenient way to program some event handling. For example, you can use an accelerator table to enable a dialog with a multi-line text control to accept CTRL-Enter as meaning 'OK'.
   # </p>
-  # </div>>
+  # </div>
   # 
   # Category:  Data Structures
   # Predefined objects/pointers: {Wx::NULL_ACCELERATOR_TABLE}
@@ -158,6 +163,7 @@ module Wx
     #   @return [Wx::AcceleratorTable]
     # @overload initialize(resource)
     #   Loads the accelerator table from a Windows resource (Windows only).
+    #   
     #   Availability:  only available for the WXMSW port.
     #   @param resource [String]  Name of a Windows accelerator.
     #   @return [Wx::AcceleratorTable]

data/lib/wx/doc/gen/accessible.rb

@@ -635,6 +635,7 @@ module Wx
   end # AccSelectionFlags
   
   # The {Wx::Accessible} class allows wxWidgets applications, and wxWidgets itself, to return extended information about user interface elements to client applications such as screen readers.
+  # 
   # This is the main way in which wxWidgets implements accessibility features.
   # At present, only Microsoft Active Accessibility is supported by this class.
   # To use this class, derive from {Wx::Accessible}, implement appropriate functions, and associate an object of the class with a window using {Wx::Window#set_accessible}.
@@ -653,12 +654,14 @@ module Wx
   class Accessible < Object
   
     # Constructor, taking an optional window.
+    # 
     # The object can be associated with a window later.
     # @param win [Wx::Window] 
     # @return [Wx::Accessible]
     def initialize(win=nil) end
     
     # Performs the default action for the object.
+    # 
     # childId is 0 (the action for this object) or greater than 0 (the action for a child).
     # {Wx::AccStatus::ACC_NOT_SUPPORTED} if there is no default action for this window (e.g. an edit control).
     # @param childId [Integer] 
@@ -666,6 +669,7 @@ module Wx
     def do_default_action(childId) end
     
     # Gets the specified child (starting from 1).
+    # 
     # If child is NULL and the return value is {Wx::AccStatus::ACC_OK}, this means that the child is a simple element and not an accessible object.
     # @param childId [Integer] 
     # @return [Array(Wx::AccStatus,Wx::Accessible)]
@@ -678,6 +682,7 @@ module Wx
     alias_method :child_count, :get_child_count
     
     # Gets the default action for this object (0) or a child (greater than 0).
+    # 
     # Return {Wx::AccStatus::ACC_OK} even if there is no action. actionName is the action, or the empty string if there is no action. The retrieved string describes the action that is performed on an object, not what the object does as a result. For example, a toolbar button that prints a document has a default action of "Press" rather than "Prints
     # the current document."
     # @param childId [Integer] 
@@ -692,6 +697,7 @@ module Wx
     alias_method :description, :get_description
     
     # Gets the window with the keyboard focus.
+    # 
     # If childId is 0 and child is NULL, no object in this subhierarchy has the focus. If this object has the focus, child should be 'this'.
     # @return [Array(Wx::AccStatus,Integer,Wx::Accessible)]
     def get_focus; end
@@ -704,6 +710,7 @@ module Wx
     alias_method :help_text, :get_help_text
     
     # Returns the keyboard shortcut for this object or child.
+    # 
     # Returns e.g. ALT+K.
     # @param childId [Integer] 
     # @return [Array(Wx::AccStatus,String)]
@@ -711,6 +718,7 @@ module Wx
     alias_method :keyboard_shortcut, :get_keyboard_shortcut
     
     # Returns the rectangle for this object (id is 0) or a child element (id is greater than 0).
+    # 
     # rect is in screen coordinates.
     # @param rect [Wx::Rect] 
     # @param elementId [Integer] 
@@ -730,6 +738,7 @@ module Wx
     alias_method :parent, :get_parent
     
     # Returns a role constant describing this object.
+    # 
     # See {Wx::AccRole} for a list of these roles.
     # @param childId [Integer] 
     # @return [Array(Wx::AccStatus,Wx::AccRole)]
@@ -737,6 +746,7 @@ module Wx
     alias_method :role, :get_role
     
     # Gets a variant representing the selected children of this object.
+    # 
     # Acceptable values are: 
     # 
     # - a null variant (<code>IsNull()</code> returns true) if no children are selected 
@@ -752,6 +762,7 @@ module Wx
     alias_method :selections, :get_selections
     
     # Returns a state constant.
+    # 
     # See {Wx::AccStatus} for a list of these states.
     # @param childId [Integer] 
     # @return [Array(Wx::AccStatus,Integer)]
@@ -770,6 +781,7 @@ module Wx
     alias_method :window, :get_window
     
     # Returns a status value and object id to indicate whether the given point was on this or a child object.
+    # 
     # Can return either a child object, or an integer representing the child element, starting from 1.
     # pt is in screen coordinates.
     # @param pt [Array(Integer, Integer), Wx::Point] 
@@ -783,6 +795,7 @@ module Wx
     def navigate(navDir, fromId) end
     
     # Selects the object or child.
+    # 
     # See {Wx::AccSelectionFlags} for a list of the selection actions.
     # @param childId [Integer] 
     # @param selectFlags [Wx::AccSelectionFlags] 

data/lib/wx/doc/gen/activity_indicator.rb

@@ -7,6 +7,7 @@
 module Wx
 
   # Small control showing an animation indicating that the program is currently busy performing some background task.
+  # 
   # Category:  {Wx::Controls}  <div class='appearance'><span class='appearance'>Appearance:</span><table><tr><td> WXMSW Appearance
   #   </td><td> WXGTK Appearance
   #   </td><td> WXOSX Appearance
@@ -17,10 +18,12 @@ module Wx
   
     # @overload initialize()
     #   Default constructor.
+    #   
     #   Use {Wx::ActivityIndicator#create} to really create the control after using this constructor.
     #   @return [Wx::ActivityIndicator]
     # @overload initialize(parent, winid=Wx::StandardID::ID_ANY, pos=Wx::DEFAULT_POSITION, size=Wx::DEFAULT_SIZE, style=0, name=("ACTIVITYINDICATOR"))
     #   Constructor fully creating the control.
+    #   
     #   The arguments have the usual meanings and only parent is typically required.
     #   @param parent [Wx::Window] 
     #   @param winid [Integer] 
@@ -32,6 +35,7 @@ module Wx
     def initialize(*args) end
     
     # Create the control initialized using the default constructor.
+    # 
     # This method can be used to finish the control creation if it hadn't been done already by using the non-default constructor.
     # @param parent [Wx::Window] 
     # @param winid [Integer] 
@@ -43,16 +47,19 @@ module Wx
     def create(parent, winid=Wx::StandardID::ID_ANY, pos=Wx::DEFAULT_POSITION, size=Wx::DEFAULT_SIZE, style=0, name=("ACTIVITYINDICATOR")) end
     
     # Starts animation of the indicator.
+    # 
     # Does nothing if the indicator is already running.
     # @return [void]
     def start; end
     
     # Stops the animation of the indicator.
+    # 
     # Notice that the animation is stopped even if {Wx::ActivityIndicator#start} had been called multiple times before, i.e. the calls are not cumulative.
     # @return [void]
     def stop; end
     
     # Returns true if the control is currently showing activity.
+    # 
     # Returns false initially, true once {Wx::ActivityIndicator#start} is called and false again after calling {Wx::ActivityIndicator#stop}.
     # @return [Boolean]
     def is_running; end