wxruby3 0.9.1-x64-mingw-ucrt → 0.9.3-x64-mingw-ucrt

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

@@ -7,30 +7,32 @@
 module Wx
 
   # Objects of this class are similar in appearance to the normal {Wx::Buttons} but are similar to the links in a web page in functionality.
+  # 
   # Pressing such button usually results in switching to another window of the program and so they can be used as a replacement for the "Next" button in a multi-page dialog (such as {Wx::Wizard}), for example.
   # Their advantage compared to the ordinary {Wx::Buttons} is that they emphasize the action of switching the window and also that they allow to give more detailed explanation to the user because, in addition to the short button label, they also show a longer description string.
   # The short, title-like, part of the label is called the main label and the longer description is the note. Both of them can be set and queried independently using {Wx::CommandLinkButton}-specific methods such as {Wx::CommandLinkButton#set_main_label} or {Wx::CommandLinkButton#get_note} or also via {Wx::CommandLinkButton#set_label} and {Wx::CommandLinkButton#get_label} methods inherited from {Wx::Button}. When using the latter, the main label and the note are concatenated into a single string using a new line character between them (notice that the note part can have more new lines in it).
   # {Wx::CommandLinkButton} generates the same event as {Wx::Button} but doesn't support any of {Wx::Button}-specific styles nor adds any new styles of its own.
   # Currently this class uses native implementation under Windows Vista and later versions and a generic implementation for the other platforms and earlier Windows versions.
   # 
-  # === 
-  # 
-  # Category:  {Wx::Controls}  <div class='appearance'><span class='appearance'>Appearance:</span><table><tr><td> wxMSW Appearance
-  #   </td><td> wxGTK Appearance
-  #   </td><td> wxOSX Appearance
+  # Category:  {Wx::Controls}  <div class='appearance'><span class='appearance'>Appearance:</span><table><tr><td> WXMSW Appearance
+  #   </td><td> WXGTK Appearance
+  #   </td><td> WXOSX Appearance
   #   </td></tr></table></div>
   # @see Wx::Button
   # @see  Wx::BitmapButton 
   # 
   # 
+  # @wxrb_require USE_BUTTON
   class CommandLinkButton < Button
   
     # @overload initialize()
     #   Default constructor.
+    #   
     #   Use {Wx::CommandLinkButton#create} to really create the control.
     #   @return [Wx::CommandLinkButton]
     # @overload initialize(parent, id, mainLabel=(''), note=(''), pos=Wx::DEFAULT_POSITION, size=Wx::DEFAULT_SIZE, style=0, validator=Wx::DEFAULT_VALIDATOR, name=Wx::BUTTON_NAME_STR)
     #   Constructor really creating a command Link button.
+    #   
     #   The button will be decorated with stock icons under GTK+ 2.
     #   @see Wx::CommandLinkButton#create
     #   @see  Wx::Validator 
@@ -47,6 +49,7 @@ module Wx
     def initialize(*args) end
     
     # Button creation function for two-step creation.
+    # 
     # For more details, see {Wx::CommandLinkButton#initialize}.
     # @param parent [Wx::Window] 
     # @param id [Integer] 
@@ -61,6 +64,7 @@ module Wx
     def create(parent, id, mainLabel=(''), note=(''), pos=Wx::DEFAULT_POSITION, size=Wx::DEFAULT_SIZE, style=0, validator=Wx::DEFAULT_VALIDATOR, name=Wx::BUTTON_NAME_STR) end
     
     # Sets a new main label and note for the button.
+    # 
     # Neither of the arguments can be empty, if you need to change just the label or just the note, use {Wx::CommandLinkButton#set_main_label} or {Wx::CommandLinkButton#set_note} instead of this function.
     # @param mainLabel [String]  New main label to use.
     # @param note [String]  New note to use.
@@ -74,6 +78,7 @@ module Wx
     alias_method :label=, :set_label
     
     # Returns the string label for the button.
+    # 
     # A string with the main label and note concatenated together with a newline separating them.
     # @see Wx::CommandLinkButton#set_label
     # @return [String]
@@ -93,12 +98,14 @@ module Wx
     alias_method :note=, :set_note
     
     # Returns the current main label.
+    # 
     # Main label currently displayed.
     # @return [String]
     def get_main_label; end
     alias_method :main_label, :get_main_label
     
     # Returns the currently used note.
+    # 
     # Note currently displayed.
     # @return [String]
     def get_note; end

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

@@ -7,19 +7,25 @@
 module Wx
 
   # Instances of this class may be used to add a question mark button that when pressed, puts the application into context-help mode.
+  # 
   # It does this by creating a {Wx::ContextHelp} object which itself generates a {Wx::EVT_HELP} event when the user clicks on a window.
   # On Windows, you may add a question-mark icon to a dialog by use of the {Wx::DIALOG_EX_CONTEXTHELP} extra style, but on other platforms you will have to add a button explicitly, usually next to OK, Cancel or similar buttons.
-  # === 
   # 
   # Category:  {Wx::HELP}
   # @see Wx::BitmapButton
   # @see  Wx::ContextHelp 
   # 
   # 
+  # @wxrb_require USE_HELP
   class ContextHelpButton < BitmapButton
   
     # Constructor, creating and showing a context help button.
-    # Normally you only need pass the parent window to the constructor, and use the defaults for the remaining parameters.
+    # 
+    # <div class="wxrb-remark">
+    # <b>Remark:</b>
+    # <p>Normally you only need pass the parent window to the constructor, and use the defaults for the remaining parameters. 
+    # </p>
+    # </div>
     # @param parent [Wx::Window]  Parent window. Must not be NULL.
     # @param id [Integer]  Button identifier. Defaults to {Wx::StandardID::ID_CONTEXT_HELP}.
     # @param pos [Array(Integer, Integer), Wx::Point]  Button position. If {Wx::DEFAULT_POSITION} is specified then a default position is chosen.
@@ -31,6 +37,7 @@ module Wx
   end # ContextHelpButton
   
   # This class changes the cursor to a query and puts the application into a 'context-sensitive help mode'.
+  # 
   # When the user left-clicks on a window within the specified window, a {Wx::EVT_HELP} event is sent to that control, and the application may respond to it by popping up some help.
   # For example: 
   # ```ruby
@@ -48,7 +55,6 @@ module Wx
   # - Create a {Wx::ContextHelpButton}, whose predefined behaviour is to create a context help object. Normally you will write your application so that this button is only added to a dialog for non-Windows platforms (use {Wx::DIALOG_EX_CONTEXTHELP} on Windows).
   # 
   # Note that on macOS, the cursor does not change when in context-sensitive help mode.
-  # === 
   # 
   # Category:  {Wx::HELP}
   # @see Wx::HelpEvent
@@ -56,9 +62,11 @@ module Wx
   # @see  Wx::ContextHelpButton 
   # 
   # 
+  # @wxrb_require USE_HELP
   class ContextHelp < Object
   
     # Constructs a context help object, calling {Wx::ContextHelp#begin_context_help} if doNow is true (the default).
+    # 
     # If window is NULL, the top window is used.
     # @param window [Wx::Window] 
     # @param doNow [Boolean] 
@@ -66,6 +74,7 @@ module Wx
     def initialize(window=nil, doNow=true) end
     
     # Puts the application into context-sensitive help mode.
+    # 
     # window is the window which will be used to catch events; if NULL, the top window will be used.
     # Returns true if the application was successfully put into context-sensitive help mode. This function only returns when the event loop has finished.
     # @param window [Wx::Window] 
@@ -73,6 +82,7 @@ module Wx
     def begin_context_help(window) end
     
     # Ends context-sensitive help mode.
+    # 
     # Not normally called by the application.
     # @return [Boolean]
     def end_context_help; end

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

@@ -7,8 +7,9 @@
 module Wx
 
   # This is the base class for a control or "widget".
+  # 
   # A control is generally a small window which processes user input and/or displays one or more item of data.
-  # === Events emitted by this class
+  # ### Events emitted by this class
   # 
   # The following event-handler methods redirect the events to member method or handler blocks for {Wx::ClipboardTextEvent} events.
   # Event handler methods for events emitted by this class:
@@ -19,8 +20,6 @@ module Wx
   # 
   # - {Wx::EvtHandler#evt_text_paste}(id, meth = nil, &block): Clipboard content was pasted into the control. 
   # 
-  # === 
-  # 
   # Category:  {Wx::Controls}
   # @see Wx::Validator 
   # 
@@ -54,12 +53,14 @@ module Wx
     
     # Simulates the effect of the user issuing a command to the item.
     # 
+    # 
     # @see Wx::CommandEvent 
     # @param event [Wx::CommandEvent] 
     # @return [void]
     def command(event) end
     
     # Returns the control's label, as it was passed to {Wx::Control#set_label}.
+    # 
     # Note that the returned string may contains mnemonics ("&" characters) if they were passed to the {Wx::Control#set_label} function; use {Wx::Control#get_label_text} if they are undesired.
     # Also note that the returned string is always the string which was passed to {Wx::Control#set_label} but may be different from the string passed to {Wx::Control#set_label_text} (since this last one escapes mnemonic characters).
     # @return [String]
@@ -67,6 +68,7 @@ module Wx
     alias_method :label, :get_label
     
     # Returns the control's label without mnemonics.
+    # 
     # Note that because of the stripping of the mnemonics the returned string may differ from the string which was passed to {Wx::Control#set_label} but should always be the same which was passed to {Wx::Control#set_label_text}.
     # @return [String]
     def get_label_text; end
@@ -74,6 +76,7 @@ module Wx
     
     # @overload get_size_from_text_size(xlen, ylen=-1)
     #   Determine the size needed by the control to leave the given area for its text.
+    #   
     #   This function is mostly useful with control displaying short amounts of text that can be edited by the user, e.g. {Wx::TextCtrl}, {Wx::ComboBox}, {Wx::SearchCtrl} etc. Typically it is used to size these controls for the maximal amount of input they are supposed to contain, for example: 
     #   ```ruby
     #     # Create a control for post code entry.
@@ -86,7 +89,7 @@ module Wx
     #            postcode.get_text_extent("99999")))
     #   ```
     #   
-    #   Currently this method is only implemented for {Wx::TextCtrl}, {Wx::ComboBox} and {Wx::Choice} in wxMSW and wxGTK.
+    #   Currently this method is only implemented for {Wx::TextCtrl}, {Wx::ComboBox} and {Wx::Choice} in WXMSW and WXGTK.
     #   
     #   The size that the control should have to leave the area of the specified size for its text. May return {Wx::DEFAULT_SIZE} if this method is not implemented for this particular control under the current platform.
     #   @param xlen [Integer]  The horizontal extent of the area to leave for text, in pixels.
@@ -100,6 +103,7 @@ module Wx
     alias_method :size_from_text_size, :get_size_from_text_size
     
     # Determine the minimum size needed by the control to display the given text.
+    # 
     # The helper function that uses combination of {Wx::Control#get_size_from_text_size} and {Wx::Control#get_text_extent} which used together pretty often: 
     # ```ruby
     #   def get_size_from_text(text)
@@ -114,6 +118,7 @@ module Wx
     alias_method :size_from_text, :get_size_from_text
     
     # Sets the control's label.
+    # 
     # All "&" characters in the label are special and indicate that the following character is a mnemonic for this control and can be used to activate it from the keyboard (typically by using Alt key in combination with it). To insert a literal ampersand character, you need to double it, i.e. use "&&". If this behaviour is undesirable, use {Wx::Control#set_label_text} instead.
     # @param label [String] 
     # @return [void]
@@ -121,6 +126,7 @@ module Wx
     alias_method :label=, :set_label
     
     # Sets the control's label to exactly the given string.
+    # 
     # Unlike {Wx::Control#set_label}, this function shows exactly the text passed to it in the control, without interpreting ampersands in it in any way. Notice that it means that the control can't have any mnemonic defined for it using this function.
     # @see Wx::Control.escape_mnemonics 
     # @param text [String] 
@@ -129,6 +135,7 @@ module Wx
     alias_method :label_text=, :set_label_text
     
     # Sets the controls label to a string using markup.
+    # 
     # Simple markup supported by this function can be used to apply different fonts or colours to different parts of the control label when supported. If markup is not supported by the control or platform, it is simply stripped and {Wx::Control#set_label} is used with the resulting string.
     # For example, 
     # ```ruby
@@ -138,7 +145,7 @@ module Wx
     #                         "<span foreground='red'>breakfast</span> "+
     #                         "available <big>HERE</big>")
     # ```
-    #  would show the string using bold, red and big for the corresponding words under wxGTK but will simply show the string "Bed &amp; breakfast
+    #  would show the string using bold, red and big for the corresponding words under WXGTK but will simply show the string "Bed &amp; breakfast
     # available HERE" on the other platforms. In any case, the "B" of "Bed" will be underlined to indicate that it can be used as a mnemonic for this control.
     # The supported tags are: 
     # <b>Tag</b> 
@@ -214,19 +221,25 @@ module Wx
     # 
     # true if the new label was set (even if markup in it was ignored) or false if we failed to parse the markup. In this case the label remains unchanged.
     # 
-    # Currently {Wx::Button} supports markup in all major ports (wxMSW, wxGTK and wxOSX/Cocoa) while {Wx::StaticText} supports it in wxGTK and wxOSX and its generic version (which can be used under MSW if markup support is required). Extending support to more controls is planned in the future.
-    # @param markup [String]  String containing markup for the label. It may contain markup tags described above and newline characters but currently only wxGTK and wxOSX support multiline labels with markup, the generic implementation (also used in wxMSW) only handles single line markup labels. Notice that the string must be well-formed (e.g. all tags must be correctly closed) and won't be shown at all otherwise.
+    # Currently {Wx::Button} supports markup in all major ports (WXMSW, WXGTK and WXOSX/Cocoa) while {Wx::StaticText} supports it in WXGTK and WXOSX and its generic version (which can be used under MSW if markup support is required). Extending support to more controls is planned in the future.
+    # @param markup [String]  String containing markup for the label. It may contain markup tags described above and newline characters but currently only WXGTK and WXOSX support multiline labels with markup, the generic implementation (also used in WXMSW) only handles single line markup labels. Notice that the string must be well-formed (e.g. all tags must be correctly closed) and won't be shown at all otherwise.
     # @return [Boolean]
     def set_label_markup(markup) end
     alias_method :label_markup=, :set_label_markup
     
     # Returns the given str string without mnemonics ("&" characters).
-    # This function is identical to {Wx::Control#get_label_text} and is provided mostly for symmetry with {Wx::Control.escape_mnemonics}.
+    # 
+    # <div class="wxrb-note">
+    # <b>Note:</b>
+    # <p>This function is identical to {Wx::Control#get_label_text} and is provided mostly for symmetry with {Wx::Control.escape_mnemonics}. 
+    # </p>
+    # </div>
     # @param str [String] 
     # @return [String]
     def self.remove_mnemonics(str) end
     
     # Escapes the special mnemonics characters ("&") in the given string.
+    # 
     # This function can be helpful if you need to set the controls label to a user-provided string. If the string contains ampersands, they wouldn't appear on the display but be used instead to indicate that the character following the first of them can be used as a control mnemonic. While this can sometimes be desirable (e.g. to allow the user to configure mnemonics of the controls), more often you will want to use this function before passing a user-defined string to {Wx::Control#set_label}. Alternatively, if the label is entirely user-defined, you can just call {Wx::Control#set_label_text} directly  but this function must be used if the label is a combination of a part defined by program containing the control mnemonics and a user-defined part.
     # 
     # The same string with the ampersands in it doubled.
@@ -235,6 +248,7 @@ module Wx
     def self.escape_mnemonics(text) end
     
     # Replaces parts of the label string with ellipsis, if needed, so that it fits into maxWidth pixels if possible.
+    # 
     # Note that this function does not guarantee that the returned string will always be shorter than maxWidth; if maxWidth is extremely small, ellipsized text may be larger.
     # @param label [String]  The string to ellipsize
     # @param dc [Wx::DC]  The DC used to retrieve the character widths through the {Wx::DC#get_partial_text_extents} function.

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

@@ -7,8 +7,8 @@
 module Wx
 
   # This is convenience class that derives from both {Wx::Control} and {Wx::ItemContainer}.
+  # 
   # It is used as basis for some wxWidgets controls ({Wx::Choice} and {Wx::ListBox}).
-  # === 
   # 
   # Category:  {Wx::Controls}
   # @see Wx::ItemContainer
@@ -19,22 +19,26 @@ module Wx
   
     # @overload append(item)
     #   Appends item into the control.
+    #   
     #   The return value is the index of the newly inserted item. Note that this may be different from the last one if the control is sorted (e.g. has {Wx::LB_SORT} or {Wx::CB_SORT} style).
     #   @param item [String]  String to add.
     #   @return [Integer]
     # @overload append(item, clientData)
     #   Appends item into the control.
+    #   
     #   The return value is the index of the newly inserted item. Note that this may be different from the last one if the control is sorted (e.g. has {Wx::LB_SORT} or {Wx::CB_SORT} style).
     #   @param item [String]  String to add.
     #   @param clientData [Object]  Pointer to client data to associate with the new item.
     #   @return [Integer]
     # @overload append(items)
     #   Appends several items at once into the control.
+    #   
     #   Notice that calling this method is usually much faster than appending them one by one if you need to add a lot of items.
     #   @param items [Array<String>]  Array of strings to insert.
     #   @return [Integer]
     # @overload append(items, clientData)
     #   Appends several items at once into the control.
+    #   
     #   Notice that calling this method is usually much faster than appending them one by one if you need to add a lot of items.
     #   @param items [Array<String>]  Array of strings to insert.
     #   @param clientData [Array]  Array of client data pointers of the same size as items to associate with the new items.
@@ -42,29 +46,34 @@ module Wx
     def append(*args) end
     
     # Returns a pointer to the client data associated with the given item (if any).
-    # It is an error to call this function for a control which doesn't have untyped client data at all although it is OK to call it even if the given item doesn't have any client data associated with it (but other items do).
+    # 
+    # It is an error to call this function for a control which doesn't have typed client data at all although it is OK to call it even if the given item doesn't have any client data associated with it (but other items do).
+    # Notice that the returned pointer is still owned by the control and will be deleted by it, use {Wx::ControlWithItems#detach_client_object} if you want to remove the pointer from the control.
     # 
     # A pointer to the client data, or NULL if not present.
     # @param n [Integer]  The zero-based position of the item.
     # @return [Object]
-    def get_client_data(n) end
-    alias_method :client_data, :get_client_data
+    def get_client_object(n) end
+    alias_method :client_object, :get_client_object
     
-    # Associates the given untyped client data pointer with the given item.
-    # Note that it is an error to call this function if any typed client data pointers had been associated with the control items before.
+    # Associates the given typed client data pointer with the given item: the data object will be deleted when the item is deleted (either explicitly by using {Wx::ControlWithItems#delete} or implicitly when the control itself is destroyed).
+    # 
+    # Note that it is an error to call this function if any untyped client data pointers had been associated with the control items before.
     # @param n [Integer]  The zero-based item index.
     # @param data [Object]  The client data to associate with the item.
     # @return [void]
-    def set_client_data(n, data) end
+    def set_client_object(n, data) end
     
     # @overload insert(item, pos)
     #   Inserts item into the control.
+    #   
     #   The return value is the index of the newly inserted item. If the insertion failed for some reason, -1 is returned.
     #   @param item [String]  String to add.
     #   @param pos [Integer]  Position to insert item before, zero based.
     #   @return [Integer]
     # @overload insert(item, pos, clientData)
     #   Inserts item into the control.
+    #   
     #   The return value is the index of the newly inserted item. If the insertion failed for some reason, -1 is returned.
     #   @param item [String]  String to add.
     #   @param pos [Integer]  Position to insert item before, zero based.
@@ -72,6 +81,7 @@ module Wx
     #   @return [Integer]
     # @overload insert(items, pos)
     #   Inserts several items at once into the control.
+    #   
     #   Notice that calling this method is usually much faster than inserting them one by one if you need to insert a lot of items.
     #   
     #   The return value is the index of the last inserted item. If the insertion failed for some reason, -1 is returned.
@@ -80,6 +90,7 @@ module Wx
     #   @return [Integer]
     # @overload insert(items, pos, clientData)
     #   Inserts several items at once into the control.
+    #   
     #   Notice that calling this method is usually much faster than inserting them one by one if you need to insert a lot of items.
     #   
     #   The return value is the index of the last inserted item. If the insertion failed for some reason, -1 is returned.
@@ -91,11 +102,13 @@ module Wx
     
     # @overload set(items)
     #   Replaces the current control contents with the given items.
+    #   
     #   Notice that calling this method is usually much faster than appending them one by one if you need to add a lot of items.
     #   @param items [Array<String>]  Array of strings to insert.
     #   @return [void]
     # @overload set(items, clientData)
     #   Replaces the current control contents with the given items.
+    #   
     #   Notice that calling this method is usually much faster than appending them one by one if you need to add a lot of items.
     #   @param items [Array<String>]  Array of strings to insert.
     #   @param clientData [Array]  Array of client data pointers of the same size as items to associate with the new items.
@@ -103,11 +116,13 @@ module Wx
     def set(*args) end
     
     # Removes all items from the control.
+    # 
     # {Wx::ControlWithItems#clear} also deletes the client data of the existing items if it is owned by the control.
     # @return [void]
     def clear; end
     
     # Deletes an item from the control.
+    # 
     # The client data associated with the item will be also deleted if it is owned by the control. Note that it is an error (signalled by an assert failure in debug builds) to remove an item with the index negative or greater or equal than the number of items in the control.
     # If there is a currently selected item below the item being deleted, i.e. if {Wx::ControlWithItems#get_selection} returns a valid index greater than or equal to n, the selection is invalidated when this function is called. However if the selected item appears before the item being deleted, the selection is preserved unchanged.
     # @see Wx::ControlWithItems#clear 
@@ -115,18 +130,31 @@ module Wx
     # @return [void]
     def delete(n) end
     
+    # Returns the client object associated with the given item and transfers its ownership to the caller.
+    # 
+    # This method, unlike {Wx::ControlWithItems#get_client_object}, expects the caller to delete the returned pointer. It also replaces the internally stored pointer with NULL, i.e. completely detaches the client object pointer from the control.
+    # It's an error to call this method unless {Wx::ControlWithItems#has_client_object_data} returns true.
+    # 
+    # The associated client object pointer to be deleted by caller or NULL.
+    # @param n [Integer]  The zero-based item index.
+    # @return [Object]
+    def detach_client_object(n) end
+    
     # Returns true, if either untyped data (<code>void*</code>) or object data ({Wx::ClientData}*) is associated with the items of the control.
     # @return [Boolean]
     def has_client_data; end
     alias_method :has_client_data?, :has_client_data
     
-    # Returns true, if untyped data (<code>void*</code>) is associated with the items of the control.
+    # Returns true, if object data is associated with the items of the control.
+    # 
+    # Object data pointers have the type <code>wxClientData*</code> instead of <code>void*</code> and, importantly, are owned by the control, i.e. will be deleted by it, unlike their untyped counterparts.
     # @return [Boolean]
-    def has_client_untyped_data; end
-    alias_method :has_client_untyped_data?, :has_client_untyped_data
+    def has_client_object_data; end
+    alias_method :has_client_object_data?, :has_client_object_data
     
     # Returns the number of items in the control.
     # 
+    # 
     # @see Wx::ControlWithItems#is_empty 
     # @return [Integer]
     def get_count; end
@@ -134,12 +162,14 @@ module Wx
     
     # Returns true if the control is empty or false if it has some items.
     # 
+    # 
     # @see Wx::ControlWithItems#get_count 
     # @return [Boolean]
     def is_empty; end
     alias_method :empty?, :is_empty
     
     # Returns the label of the item with the given index.
+    # 
     # The index must be valid, i.e. less than the value returned by {Wx::ControlWithItems#get_count}, otherwise an assert is triggered. Notably, this function can't be called if the control is empty.
     # 
     # The label of the item.
@@ -160,6 +190,7 @@ module Wx
     def set_string(n, string) end
     
     # Finds an item whose label matches the given string.
+    # 
     # The zero-based position of the item, or {Wx::NOT_FOUND} if the string was not found.
     # @param string [String]  String to find.
     # @param caseSensitive [Boolean]  Whether search is case sensitive (default is not).
@@ -167,6 +198,7 @@ module Wx
     def find_string(string, caseSensitive=false) end
     
     # Sets the selection to the given item n or removes the selection entirely if n == {Wx::NOT_FOUND}.
+    # 
     # Note that this does not cause any command events to be emitted nor does it deselect any other items in the controls which support multiple selections.
     # @see Wx::ControlWithItems#set_string
     # @see  Wx::ControlWithItems#set_string_selection 
@@ -176,6 +208,7 @@ module Wx
     alias_method :selection=, :set_selection
     
     # Returns the index of the selected item or {Wx::NOT_FOUND} if no item is selected.
+    # 
     # The position of the current selection.
     # @see Wx::ControlWithItems#set_selection
     # @see  Wx::ControlWithItems#get_string_selection 
@@ -184,6 +217,7 @@ module Wx
     alias_method :selection, :get_selection
     
     # Selects the item with the specified string in the control.
+    # 
     # This method doesn't cause any command events to be emitted.
     # Notice that this method is case-insensitive, i.e. the string is compared with all the elements of the control case-insensitively and the first matching entry is selected, even if it doesn't have exactly the same case as this string and there is an exact match afterwards.
     # 
@@ -195,6 +229,7 @@ module Wx
     
     # Returns the label of the selected item or an empty string if no item is selected.
     # 
+    # 
     # @see Wx::ControlWithItems#get_selection 
     # @return [String]
     def get_string_selection; end

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

@@ -7,7 +7,7 @@
 module Wx
 
   # wxRuby version string
-  Wx::WXRUBY_VERSION = '0.9.1'
+  Wx::WXRUBY_VERSION = '0.9.3'
 
   # wxRuby version release type (alpha, beta, rc)
   Wx::WXRUBY_RELEASE_TYPE = ''
@@ -16,10 +16,10 @@ module Wx
   # wxRuby minor version number
   Wx::WXRUBY_MINOR = 9
   # wxRuby release number
-  Wx::WXRUBY_RELEASE = 1
+  Wx::WXRUBY_RELEASE = 3
 
   # Convenience string for WxWidgets version info
-  WXWIDGETS_VERSION = '3.2.3'
+  WXWIDGETS_VERSION = '3.2.4'
 
   # Integer constant reflecting the major version of the wxWidgets release used to build wxRuby
   WXWIDGETS_MAJOR_VERSION = 3
@@ -28,7 +28,7 @@ module Wx
   WXWIDGETS_MINOR_VERSION = 2
 
   # Integer constant reflecting the release number of the wxWidgets release used to build wxRuby
-  WXWIDGETS_RELEASE_NUMBER = 3
+  WXWIDGETS_RELEASE_NUMBER = 4
 
   # Integer constant reflecting the sub-release number of the wxWidgets release used to build wxRuby
   WXWIDGETS_SUBRELEASE_NUMBER = 0

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

@@ -11,6 +11,7 @@ module Wx
   NULL_CURSOR = nil
   
   # A cursor is a small bitmap usually used for denoting where the mouse pointer is, with a picture that might indicate the interpretation of a mouse click.
+  # 
   # As with icons, cursors in X and MS Windows are created in a different manner. Therefore, separate cursors 
   # will be created for the different environments. Platform-specific methods for creating a {Wx::Cursor} object 
   # are catered for, and this is an occasion where conditional compilation will probably be required 
@@ -19,8 +20,6 @@ module Wx
   # the cursor for a window, as in X, rather than to set it globally as in MS Windows, although a global 
   # {set_cursor} function is also available for MS Windows use.
   # 
-  # === 
-  # 
   # Category:  Graphics Device Interface (GDI)
   # Predefined objects/pointers:
   # - {Wx::NULL_CURSOR}
@@ -42,9 +41,10 @@ module Wx
     #   @return [Wx::Cursor]
     # @overload initialize(cursorName, type=Wx::CURSOR_DEFAULT_TYPE, hotSpotX=0, hotSpotY=0)
     #   Constructs a cursor by passing a string resource name or filename.
-    #   The arguments hotSpotX and hotSpotY are only used when there's no hotspot info in the resource/image-file to load (e.g. when using {Wx::BitmapType::BITMAP_TYPE_ICO} under wxMSW or {Wx::BitmapType::BITMAP_TYPE_XPM} under wxGTK).
+    #   
+    #   The arguments hotSpotX and hotSpotY are only used when there's no hotspot info in the resource/image-file to load (e.g. when using {Wx::BitmapType::BITMAP_TYPE_ICO} under WXMSW or {Wx::BitmapType::BITMAP_TYPE_XPM} under WXGTK).
     #   @param cursorName [String]  The name of the resource or the image file to load.
-    #   @param type [Wx::BitmapType]  Icon type to load. It defaults to {Wx::CURSOR_DEFAULT_TYPE}, which is a #define associated to different values on different platforms:
+    #   @param type [Wx::BitmapType]  Icon type to load. It defaults to {Wx::CURSOR_DEFAULT_TYPE}, which is a \#define associated to different values on different platforms:
     #     
     #     - under Windows, it defaults to {Wx::BITMAP_TYPE_CUR_RESOURCE}. Other permitted types under Windows are {Wx::BitmapType::BITMAP_TYPE_CUR} (to load a cursor from a .cur cursor file), {Wx::BitmapType::BITMAP_TYPE_ICO} (to load a cursor from a .ico icon file) and {Wx::BitmapType::BITMAP_TYPE_ANI} (to load a cursor from a .ani icon file).
     #     - under MacOS, it defaults to {Wx::BITMAP_TYPE_MACCURSOR_RESOURCE}; when specifying a string resource name, first the color cursors 'crsr' and then the black/white cursors 'CURS' in the resource chain are scanned through. Note that resource forks are deprecated on macOS so this is only available for legacy reasons and should not be used in new code.
@@ -60,10 +60,11 @@ module Wx
     #   @return [Wx::Cursor]
     # @overload initialize(image)
     #   Constructs a cursor from a {Wx::Image}.
+    #   
     #   If cursor are monochrome on the current platform, colors with the RGB elements all greater than 127 will be foreground, colors less than this background. The mask (if any) will be used to specify the transparent area.
-    #   In wxMSW the foreground will be white and the background black. If the cursor is larger than 32x32 it is resized.
-    #   In wxGTK, colour cursors and alpha channel are supported (starting from GTK+ 2.2). Otherwise the two most frequent colors will be used for foreground and background. In any case, the cursor will be displayed at the size of the image.
-    #   Under wxMac (Cocoa), large cursors are supported.
+    #   In WXMSW the foreground will be white and the background black. If the cursor is larger than 32x32 it is resized.
+    #   In WXGTK, colour cursors and alpha channel are supported (starting from GTK+ 2.2). Otherwise the two most frequent colors will be used for foreground and background. In any case, the cursor will be displayed at the size of the image.
+    #   Under WXOSX (Cocoa), large cursors are supported.
     #   Notice that the image can define the cursor hot spot. To set it you need to use {Wx::Image#set_option} with {Wx::IMAGE_OPTION_CUR_HOTSPOT_X} or {Wx::IMAGE_OPTION_CUR_HOTSPOT_Y}, e.g. 
     #   ```ruby
     #     image.set_option(Wx::IMAGE_OPTION_CUR_HOTSPOT_X, hotSpotX)
@@ -83,8 +84,9 @@ module Wx
     alias_method :ok?, :is_ok
     
     # Returns the coordinates of the cursor hot spot.
+    # 
     # The hot spot is the point at which the mouse is actually considered to be when this cursor is used.
-    # This method is currently only implemented in wxMSW and wxGTK2+ and simply returns {Wx::DEFAULT_POSITION} in the other ports.
+    # This method is currently only implemented in WXMSW and WXGTK2+ and simply returns {Wx::DEFAULT_POSITION} in the other ports.
     # @return [Wx::Point]
     def get_hot_spot; end
     alias_method :hot_spot, :get_hot_spot

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

@@ -7,6 +7,7 @@
 module Wx
 
   # A {Wx::DataFormat} is an encapsulation of a platform-specific format handle which is used by the system for the clipboard and drag and drop operations.
+  # 
   # The applications are usually only interested in, for example, pasting data from the clipboard only if the data is in a format the program understands and a data format is something which uniquely identifies this format.
   # On the system level, a data format is usually just a number (CLIPFORMAT under Windows or Atom under X11, for example) and the standard formats are, indeed, just numbers which can be implicitly converted to {Wx::DataFormat}. The standard formats are:
   # 
@@ -36,7 +37,6 @@ module Wx
   # 
   # As mentioned above, these standard formats may be passed to any function taking {Wx::DataFormat} argument because {Wx::DataFormat} has an implicit conversion from them (or, to be precise from the type {Wx::DataFormat::NativeFormat} which is the type used by the underlying platform for data formats).
   # Aside the standard formats, the application may also use custom formats which are identified by their names (strings) and not numeric identifiers. Although internally custom format must be created (or registered) first, you shouldn't care about it because it is done automatically the first time the {Wx::DataFormat} object corresponding to a given format name is created. The only implication of this is that you should avoid having global {Wx::DataFormat} objects with non-default constructor because their constructors are executed before the program has time to perform all necessary initialisations and so an attempt to do clipboard format registration at this time will usually lead to a crash!
-  # === 
   # 
   # Category:  Clipboard and Drag & Drop
   # @see Drag and Drop Overview
@@ -44,6 +44,7 @@ module Wx
   # @see  Wx::DataObject 
   # 
   # 
+  # @wxrb_require USE_CLIPBOARD
   class DataFormat < ::Object
   
     # @overload initialize(format=Wx::DataFormatId::DF_INVALID)
@@ -61,6 +62,11 @@ module Wx
     def get_id; end
     alias_method :id, :get_id
     
+    # Returns the platform-specific number identifying the format.
+    # @return [Wx::DataFormatId]
+    def get_type; end
+    alias_method :type, :get_type
+    
     # Sets the format to be the custom format identified by the given name.
     # @param format [String] 
     # @return [void]