wxruby3 0.9.0.pre.rc.2-x64-mingw-ucrt → 0.9.0.pre.rc.3-x64-mingw-ucrt

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

@@ -236,7 +236,7 @@ module Wx
   # 
   # {Wx::TreeCtrl} inherits from {Wx::WithImages} classes providing the functions for associating images with the control items. Each item refers to its image using an index, which can possibly by {Wx::WithImages::NO_IMAGE} to indicate that the item doesn't use any image at all, and the corresponding image is taken either from the vector passed to {Wx::WithImages#set_images} or from the image list passed to {Wx::WithImages#set_image_list} or {Wx::WithImages#assign_image_list} functions.
   # In addition to normal images, handled with the methods mentioned above, {Wx::TreeCtrl} also provides optional state images that may be used to indicate some additional state of the item, e.g. checked or unchecked status. These images can be set using {Wx::TreeCtrl#set_state_image_list} and {Wx::TreeCtrl#assign_state_image_list} functions that behave in the same way as the corresponding methods of {Wx::WithImages}.
-  # Finally, in the generic version of this control ({Wx::GenericTreeCtrl}), also provides {Wx::TreeCtrl#set_buttons_image_list} and {Wx::TreeCtrl#assign_buttons_image_list}, which can be used to change the images used for the control buttons, used to expand or collapse its branches. These methods are not available in the native {Wx::MSW} and {Wx::Qt} implementations.
+  # Finally, in the generic version of this control ({Wx::GenericTreeCtrl}), also provides {Wx::TreeCtrl#set_buttons_image_list} and {Wx::TreeCtrl#assign_buttons_image_list}, which can be used to change the images used for the control buttons, used to expand or collapse its branches. These methods are not available in the native wxMSW and {Wx::Qt} implementations.
   # 
   # == Events
   # 
@@ -244,45 +244,78 @@ module Wx
   # === Styles
   # 
   # This class supports the following styles:
-  #  
+  # 
   # - {Wx::TR_EDIT_LABELS}: Use this style if you wish the user to be able to edit labels in the tree control. 
+  # 
   # - {Wx::TR_NO_BUTTONS}: For convenience to document that no buttons are to be drawn. 
+  # 
   # - {Wx::TR_HAS_BUTTONS}: Use this style to show + and - buttons to the left of parent items. 
+  # 
   # - {Wx::TR_TWIST_BUTTONS}: Selects alternative style of <code>+/<code>-</code> buttons</code> and shows rotating ("twisting") arrows instead. Currently this style is only implemented under Microsoft Windows Vista and later Windows versions and is ignored under the other platforms as enabling it is equivalent to using Wx::SystemThemedControl#enable_system_theme. 
+  # 
   # - {Wx::TR_NO_LINES}: Use this style to hide vertical level connectors. 
+  # 
   # - {Wx::TR_FULL_ROW_HIGHLIGHT}: Use this style to have the background colour and the selection highlight extend over the entire horizontal row of the tree control window. (This flag is ignored under Windows unless you specify {Wx::TR_NO_LINES} as well.) 
+  # 
   # - {Wx::TR_LINES_AT_ROOT}: Use this style to show lines leading to the root nodes (unless no {Wx::TR_NO_LINES} is also used, in which case no lines are shown). Note that in the MSW version, if this style is omitted, not only the lines, but also the button used for expanding the root item is not shown, which can be unexpected, so it is recommended to always use it. 
+  # 
   # - {Wx::TR_HIDE_ROOT}: Use this style to suppress the display of the root node, effectively causing the first-level nodes to appear as a series of root nodes. 
+  # 
   # - {Wx::TR_ROW_LINES}: Use this style to draw a contrasting border between displayed rows. 
+  # 
   # - {Wx::TR_HAS_VARIABLE_ROW_HEIGHT}: Use this style to cause row heights to be just big enough to fit the content. If not set, all rows use the largest row height. The default is that this flag is unset. Generic only. 
+  # 
   # - {Wx::TR_SINGLE}: For convenience to document that only one item may be selected at a time. Selecting another item causes the current selection, if any, to be deselected. This is the default. 
+  # 
   # - {Wx::TR_MULTIPLE}: Use this style to allow a range of items to be selected. If a second range is selected, the current range, if any, is deselected. 
+  # 
   # - {Wx::TR_DEFAULT_STYLE}: The set of flags that are closest to the defaults for the native control for a particular toolkit. 
   # 
   # === Events emitted by this class
   # 
   # The following event-handler methods redirect the events to member method or handler blocks for {Wx::TreeEvent} events.
   # Event handler methods for events emitted by this class:
+  # 
   # - {Wx::EvtHandler#evt_tree_begin_drag}(id, meth = nil, &block): Begin dragging with the left mouse button. If you want to enable left-dragging you need to intercept this event and explicitly call {Wx::TreeEvent#allow}, as it's vetoed by default. Processes a {Wx::EVT_TREE_BEGIN_DRAG} event type. 
+  # 
   # - {Wx::EvtHandler#evt_tree_begin_rdrag}(id, meth = nil, &block): Begin dragging with the right mouse button. If you want to enable right-dragging you need to intercept this event and explicitly call {Wx::TreeEvent#allow}, as it's vetoed by default. Processes a {Wx::EVT_TREE_BEGIN_RDRAG} event type. 
+  # 
   # - {Wx::EvtHandler#evt_tree_end_drag}(id, meth = nil, &block): End dragging with the left or right mouse button. Processes a {Wx::EVT_TREE_END_DRAG} event type. 
+  # 
   # - {Wx::EvtHandler#evt_tree_begin_label_edit}(id, meth = nil, &block): Begin editing a label. This can be prevented by calling Veto(). Processes a {Wx::EVT_TREE_BEGIN_LABEL_EDIT} event type. 
+  # 
   # - {Wx::EvtHandler#evt_tree_end_label_edit}(id, meth = nil, &block): Finish editing a label. This can be prevented by calling Veto(). Processes a {Wx::EVT_TREE_END_LABEL_EDIT} event type. 
+  # 
   # - {Wx::EvtHandler#evt_tree_delete_item}(id, meth = nil, &block): An item was deleted. Processes a {Wx::EVT_TREE_DELETE_ITEM} event type. 
+  # 
   # - {Wx::EvtHandler#evt_tree_get_info}(id, meth = nil, &block): Request information from the application. Processes a {Wx::EVT_TREE_GET_INFO} event type. 
+  # 
   # - {Wx::EvtHandler#evt_tree_set_info}(id, meth = nil, &block): Information is being supplied. Processes a {Wx::EVT_TREE_SET_INFO} event type. 
+  # 
   # - {Wx::EvtHandler#evt_tree_item_activated}(id, meth = nil, &block): The item has been activated, i.e. chosen by double clicking it with mouse or from keyboard. Processes a {Wx::EVT_TREE_ITEM_ACTIVATED} event type. 
+  # 
   # - {Wx::EvtHandler#evt_tree_item_collapsed}(id, meth = nil, &block): The item has been collapsed. Processes a {Wx::EVT_TREE_ITEM_COLLAPSED} event type. 
+  # 
   # - {Wx::EvtHandler#evt_tree_item_collapsing}(id, meth = nil, &block): The item is being collapsed. This can be prevented by calling Veto(). Processes a {Wx::EVT_TREE_ITEM_COLLAPSING} event type. 
+  # 
   # - {Wx::EvtHandler#evt_tree_item_expanded}(id, meth = nil, &block): The item has been expanded. Processes a {Wx::EVT_TREE_ITEM_EXPANDED} event type. 
+  # 
   # - {Wx::EvtHandler#evt_tree_item_expanding}(id, meth = nil, &block): The item is being expanded. This can be prevented by calling Veto(). Processes a {Wx::EVT_TREE_ITEM_EXPANDING} event type. 
+  # 
   # - {Wx::EvtHandler#evt_tree_item_right_click}(id, meth = nil, &block): The user has clicked the item with the right mouse button. Processes a {Wx::EVT_TREE_ITEM_RIGHT_CLICK} event type. 
+  # 
   # - {Wx::EvtHandler#evt_tree_item_middle_click}(id, meth = nil, &block): The user has clicked the item with the middle mouse button. This is only supported by the generic control. Processes a {Wx::EVT_TREE_ITEM_MIDDLE_CLICK} event type. 
+  # 
   # - {Wx::EvtHandler#evt_tree_sel_changed}(id, meth = nil, &block): Selection has changed. Processes a {Wx::EVT_TREE_SEL_CHANGED} event type. 
+  # 
   # - {Wx::EvtHandler#evt_tree_sel_changing}(id, meth = nil, &block): Selection is changing. This can be prevented by calling Veto(). Processes a {Wx::EVT_TREE_SEL_CHANGING} event type. 
+  # 
   # - {Wx::EvtHandler#evt_tree_key_down}(id, meth = nil, &block): A key has been pressed. Processes a {Wx::EVT_TREE_KEY_DOWN} event type. 
+  # 
   # - {Wx::EvtHandler#evt_tree_item_gettooltip}(id, meth = nil, &block): The opportunity to set the item tooltip is being given to the application (call {Wx::TreeEvent#set_tool_tip}). Windows only. Processes a {Wx::EVT_TREE_ITEM_GETTOOLTIP} event type. 
+  # 
   # - {Wx::EvtHandler#evt_tree_item_menu}(id, meth = nil, &block): The context menu for the selected item has been requested, either by a right click or by using the menu key. Notice that these events always carry a valid tree item and so are not generated when (right) clicking outside of the items area. If you need to handle such events, consider using {Wx::EVT_CONTEXT_MENU} instead. Processes a {Wx::EVT_TREE_ITEM_MENU} event type. 
+  # 
   # - {Wx::EvtHandler#evt_tree_state_image_click}(id, meth = nil, &block): The state image has been clicked. Processes a {Wx::EVT_TREE_STATE_IMAGE_CLICK} event type. 
   # 
   # See also Window Styles.
@@ -290,9 +323,9 @@ module Wx
   # {Wx::TreeCtrl} class uses the standard common treeview control under Win32 implemented in the system library comctl32.dll. Some versions of this library are known to have bugs with handling the tree control colours: the usual symptom is that the expanded items leave black (or otherwise incorrectly coloured) background behind them, especially for the controls using non-default background colour. The recommended solution is to upgrade the comctl32.dll to a newer version: see http://www.microsoft.com/downloads/details.aspx?familyid=cb2cf3a2-8025-4e8f-8511-9b476a8d35d2
   # === 
   # 
-  # Category:  {Wx::Controls}  <div class='appearance'><span class='appearance'>Appearance:</span><table><tr><td> {Wx::MSW} Appearance
-  #   </td><td> {Wx::GTK} Appearance
-  #   </td><td> {Wx::OSX} 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::DataViewTreeCtrl
   # @see  Wx::TreeEvent
@@ -309,7 +342,7 @@ module Wx
   
     # @overload initialize()
     #   Default Constructor.
-    #   @return [TreeCtrl]
+    #   @return [Wx::TreeCtrl]
     # @overload initialize(parent, id=Wx::StandardID::ID_ANY, pos=Wx::DEFAULT_POSITION, size=Wx::DEFAULT_SIZE, style=Wx::TR_DEFAULT_STYLE, validator=Wx::DEFAULT_VALIDATOR, name=Wx::TreeCtrlNameStr)
     #   Constructor, creating and showing a tree control.
     #   
@@ -322,7 +355,7 @@ module Wx
     #   @param style [Integer]  Window style. See {Wx::TreeCtrl}.
     #   @param validator [Wx::Validator]  Window validator.
     #   @param name [String]  Window name.
-    #   @return [TreeCtrl]
+    #   @return [Wx::TreeCtrl]
     def initialize(*args) end
     
     # Adds the root node to the tree, returning the new item.
@@ -399,7 +432,7 @@ module Wx
     def delete_children(item) end
     
     # Enable or disable a beep if there is no match for the currently entered text when searching for the item from keyboard.
-    # The default is to not beep in this case except in {Wx::MSW} where the beep is always generated by the native control and cannot be disabled, i.e. calls to this function do nothing there.
+    # The default is to not beep in this case except in wxMSW where the beep is always generated by the native control and cannot be disabled, i.e. calls to this function do nothing there.
     # @param on [true,false] 
     # @return [void]
     def enable_bell_on_no_match(on=true) end
@@ -459,7 +492,7 @@ module Wx
     
     # Returns the edit control being currently used to edit a label.
     # Returns NULL if no label is being edited.
-    # This is currently only implemented for {Wx::MSW}.
+    # This is currently only implemented for wxMSW.
     # @return [Wx::TextCtrl]
     def get_edit_control; end
     alias_method :edit_control, :get_edit_control
@@ -519,7 +552,11 @@ module Wx
     
     # Gets the specified item image.
     # The value of which may be:
-    # - {Wx::TreeItemIcon::TreeItemIcon_Normal}: to get the normal item image.- {Wx::TreeItemIcon::TreeItemIcon_Selected}: to get the selected item image (i.e. the image which is shown when the item is currently selected).- {Wx::TreeItemIcon::TreeItemIcon_Expanded}: to get the expanded image (this only makes sense for items which have children - then this image is shown when the item is expanded and the normal image is shown when it is collapsed).- {Wx::TreeItemIcon::TreeItemIcon_SelectedExpanded}: to get the selected expanded image (which is shown when an expanded item is currently selected).
+    # 
+    # - {Wx::TreeItemIcon::TreeItemIcon_Normal}: to get the normal item image.
+    # - {Wx::TreeItemIcon::TreeItemIcon_Selected}: to get the selected item image (i.e. the image which is shown when the item is currently selected).
+    # - {Wx::TreeItemIcon::TreeItemIcon_Expanded}: to get the expanded image (this only makes sense for items which have children - then this image is shown when the item is expanded and the normal image is shown when it is collapsed).
+    # - {Wx::TreeItemIcon::TreeItemIcon_SelectedExpanded}: to get the selected expanded image (which is shown when an expanded item is currently selected).
     # @param item [Wx::TreeItemId] 
     # @param which [TreeItemIcon] 
     # @return [Integer]
@@ -616,7 +653,17 @@ module Wx
     # Calculates which (if any) item is under the given point, returning the tree item id at this point plus extra information flags.
     # flags is a bitlist of the following:
     # 
-    # - {Wx::TREE_HITTEST_ABOVE}: Above the client area.- {Wx::TREE_HITTEST_BELOW}: Below the client area.- {Wx::TREE_HITTEST_NOWHERE}: In the client area but below the last item.- {Wx::TREE_HITTEST_ONITEMBUTTON}: On the button associated with an item.- {Wx::TREE_HITTEST_ONITEMICON}: On the bitmap associated with an item.- {Wx::TREE_HITTEST_ONITEMINDENT}: In the indentation associated with an item.- {Wx::TREE_HITTEST_ONITEMLABEL}: On the label (string) associated with an item.- {Wx::TREE_HITTEST_ONITEMRIGHT}: In the area to the right of an item.- {Wx::TREE_HITTEST_ONITEMSTATEICON}: On the state icon for a tree view item that is in a user-defined state.- {Wx::TREE_HITTEST_TOLEFT}: To the right of the client area.- {Wx::TREE_HITTEST_TORIGHT}: To the left of the client area.
+    # - {Wx::TREE_HITTEST_ABOVE}: Above the client area.
+    # - {Wx::TREE_HITTEST_BELOW}: Below the client area.
+    # - {Wx::TREE_HITTEST_NOWHERE}: In the client area but below the last item.
+    # - {Wx::TREE_HITTEST_ONITEMBUTTON}: On the button associated with an item.
+    # - {Wx::TREE_HITTEST_ONITEMICON}: On the bitmap associated with an item.
+    # - {Wx::TREE_HITTEST_ONITEMINDENT}: In the indentation associated with an item.
+    # - {Wx::TREE_HITTEST_ONITEMLABEL}: On the label (string) associated with an item.
+    # - {Wx::TREE_HITTEST_ONITEMRIGHT}: In the area to the right of an item.
+    # - {Wx::TREE_HITTEST_ONITEMSTATEICON}: On the state icon for a tree view item that is in a user-defined state.
+    # - {Wx::TREE_HITTEST_TOLEFT}: To the right of the client area.
+    # - {Wx::TREE_HITTEST_TORIGHT}: To the left of the client area.
     # @param point [Array(Integer, Integer), Wx::Point] 
     # @return [Array(Wx::TreeItemId,Integer)]
     def hit_test(point) end
@@ -709,7 +756,7 @@ module Wx
     alias_method :indent=, :set_indent
     
     # Sets the spacing for the tree control.
-    # Spacing is the number of horizontal pixels between the buttons and the state images. This has no effect under {Wx::MSW}.
+    # Spacing is the number of horizontal pixels between the buttons and the state images. This has no effect under wxMSW.
     # @param spacing [Integer] 
     # @return [void]
     def set_spacing(spacing) end
@@ -770,7 +817,10 @@ module Wx
     
     # Sets the specified item state.
     # The value of state may be an index into the state image list, or one of the special values:
-    # - {Wx::TREE_ITEMSTATE_NONE}: to disable the item state (the state image will be not displayed).- {Wx::TREE_ITEMSTATE_NEXT}: to set the next item state.- {Wx::TREE_ITEMSTATE_PREV}: to set the previous item state.
+    # 
+    # - {Wx::TREE_ITEMSTATE_NONE}: to disable the item state (the state image will be not displayed).
+    # - {Wx::TREE_ITEMSTATE_NEXT}: to set the next item state.
+    # - {Wx::TREE_ITEMSTATE_PREV}: to set the previous item state.
     # @param item [Wx::TreeItemId] 
     # @param state [Integer] 
     # @return [void]

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

@@ -12,26 +12,47 @@ module Wx
   # 
   # The following event-handler methods redirect the events to member method or handler blocks for {Wx::TreeEvent} events.
   # Event handler methods:
+  # 
   # - {Wx::EvtHandler#evt_tree_begin_drag}(id, meth = nil, &block): Begin dragging with the left mouse button. If you want to enable left-dragging you need to intercept this event and explicitly call {Wx::TreeEvent#allow}, as it's vetoed by default. Also notice that the control must have an associated image list (see SetImageList()) to drag its items under MSW. 
+  # 
   # - {Wx::EvtHandler#evt_tree_begin_rdrag}(id, meth = nil, &block): Begin dragging with the right mouse button. If you want to enable right-dragging you need to intercept this event and explicitly call {Wx::TreeEvent#allow}, as it's vetoed by default. 
+  # 
   # - {Wx::EvtHandler#evt_tree_end_drag}(id, meth = nil, &block): End dragging with the left or right mouse button. 
+  # 
   # - {Wx::EvtHandler#evt_tree_begin_label_edit}(id, meth = nil, &block): Begin editing a label. This can be prevented by calling {Wx::TreeEvent#veto}. 
+  # 
   # - {Wx::EvtHandler#evt_tree_end_label_edit}(id, meth = nil, &block): Finish editing a label. This can be prevented by calling {Wx::TreeEvent#veto}. 
+  # 
   # - {Wx::EvtHandler#evt_tree_delete_item}(id, meth = nil, &block): Delete an item. 
+  # 
   # - {Wx::EvtHandler#evt_tree_get_info}(id, meth = nil, &block): Request information from the application. 
+  # 
   # - {Wx::EvtHandler#evt_tree_set_info}(id, meth = nil, &block): Information is being supplied. 
+  # 
   # - {Wx::EvtHandler#evt_tree_item_activated}(id, meth = nil, &block): The item has been activated, i.e. chosen by double clicking it with mouse or from keyboard. 
+  # 
   # - {Wx::EvtHandler#evt_tree_item_collapsed}(id, meth = nil, &block): The item has been collapsed. 
+  # 
   # - {Wx::EvtHandler#evt_tree_item_collapsing}(id, meth = nil, &block): The item is being collapsed. This can be prevented by calling {Wx::TreeEvent#veto}. 
+  # 
   # - {Wx::EvtHandler#evt_tree_item_expanded}(id, meth = nil, &block): The item has been expanded. 
+  # 
   # - {Wx::EvtHandler#evt_tree_item_expanding}(id, meth = nil, &block): The item is being expanded. This can be prevented by calling {Wx::TreeEvent#veto}. 
+  # 
   # - {Wx::EvtHandler#evt_tree_item_right_click}(id, meth = nil, &block): The user has clicked the item with the right mouse button. 
+  # 
   # - {Wx::EvtHandler#evt_tree_item_middle_click}(id, meth = nil, &block): The user has clicked the item with the middle mouse button. 
+  # 
   # - {Wx::EvtHandler#evt_tree_sel_changed}(id, meth = nil, &block): Selection has changed. 
+  # 
   # - {Wx::EvtHandler#evt_tree_sel_changing}(id, meth = nil, &block): Selection is changing. This can be prevented by calling {Wx::TreeEvent#veto}. 
+  # 
   # - {Wx::EvtHandler#evt_tree_key_down}(id, meth = nil, &block): A key has been pressed. 
+  # 
   # - {Wx::EvtHandler#evt_tree_item_gettooltip}(id, meth = nil, &block): The opportunity to set the item tooltip is being given to the application (call {Wx::TreeEvent#set_tool_tip}). Windows only. 
+  # 
   # - {Wx::EvtHandler#evt_tree_item_menu}(id, meth = nil, &block): The context menu for the selected item has been requested, either by a right click or by using the menu key. 
+  # 
   # - {Wx::EvtHandler#evt_tree_state_image_click}(id, meth = nil, &block): The state image has been clicked. 
   # 
   # === 
@@ -43,10 +64,10 @@ module Wx
   class TreeEvent < NotifyEvent
   
     # Constructor, used by wxWidgets itself only.
-    # @param commandType [Integer] 
+    # @param commandType [Wx::AUI::AuiMDIChildFrame::EventType] 
     # @param tree [Wx::TreeCtrl] 
     # @param item [Wx::TreeItemId] 
-    # @return [TreeEvent]
+    # @return [Wx::TreeEvent]
     def initialize(commandType, tree, item=(Wx::TreeItemId.new())) end
     
     # Returns the item.

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

@@ -30,9 +30,13 @@ module Wx
   # 
   # The following event-handler methods redirect the events to member method or handler blocks for {Wx::BookCtrlEvent} events.
   # Event handler methods for events emitted by this class:
+  # 
   # - {Wx::EvtHandler#evt_treebook_page_changed}(id, meth = nil, &block): The page selection was changed. Processes a {Wx::EVT_TREEBOOK_PAGE_CHANGED} event. 
+  # 
   # - {Wx::EvtHandler#evt_treebook_page_changing}(id, meth = nil, &block): The page selection is about to be changed. Processes a {Wx::EVT_TREEBOOK_PAGE_CHANGING} event. This event can be {Wx::vetoed}. 
+  # 
   # - {Wx::EvtHandler#evt_treebook_node_collapsed}(id, meth = nil, &block): The page node is going to be collapsed. Processes a {Wx::EVT_TREEBOOK_NODE_COLLAPSED} event. 
+  # 
   # - {Wx::EvtHandler#evt_treebook_node_expanded}(id, meth = nil, &block): The page node is going to be expanded. Processes a {Wx::EVT_TREEBOOK_NODE_EXPANDED} event. 
   # 
   # === 
@@ -51,7 +55,7 @@ module Wx
   
     # @overload initialize()
     #   Default constructor.
-    #   @return [Treebook]
+    #   @return [Wx::Treebook]
     # @overload initialize(parent, id, pos=Wx::DEFAULT_POSITION, size=Wx::DEFAULT_SIZE, style=Wx::BK_DEFAULT, name=(''))
     #   Creates an empty {Wx::Treebook}.
     #   @param parent [Wx::Window]  The parent window. Must be non-NULL.
@@ -60,7 +64,7 @@ module Wx
     #   @param size [Array(Integer, Integer), Wx::Size]  The window size.
     #   @param style [Integer]  The window style. See {Wx::Notebook}.
     #   @param name [String]  The name of the control (used only under Motif).
-    #   @return [Treebook]
+    #   @return [Wx::Treebook]
     def initialize(*args) end
     
     # Adds a new page.

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

@@ -17,7 +17,7 @@ module Wx
   class UIActionSimulator < ::Object
   
     # Default constructor.
-    # @return [UIActionSimulator]
+    # @return [Wx::UIActionSimulator]
     def initialize; end
     
     # @overload mouse_move(x, y)

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

@@ -50,7 +50,7 @@ module Wx
   # For normal keys, returns true if the specified key is currently down.
   # For togglable keys (Caps Lock, Num Lock and Scroll Lock), returns true if the key is toggled such that its LED indicator is lit. There is currently no way to test whether togglable keys are up or down.
   # Even though there are virtual key codes defined for mouse buttons, they cannot be used with this function currently.
-  # In {Wx::GTK}, this function can be only used with modifier keys ({Wx::K_ALT}, {Wx::K_CONTROL} and {Wx::K_SHIFT}) when not using X11 backend currently.
+  # In wxGTK, this function can be only used with modifier keys ({Wx::K_ALT}, {Wx::K_CONTROL} and {Wx::K_SHIFT}) when not using X11 backend currently.
   # @param key [KeyCode] 
   # @return [true,false]
   def self.get_key_state(key) end
@@ -102,7 +102,10 @@ module Wx
   # If the flags parameter contains {Wx::BROWSER_NEW_WINDOW} flag, a new window is opened for the URL (currently this is only supported under Windows).
   # And unless the flags parameter contains {Wx::BROWSER_NOBUSYCURSOR} flag, a busy cursor is shown while the browser is being launched (using {Wx::BusyCursor}).
   # The parameter url is interpreted as follows:
-  # - if it has a valid scheme (e.g. <code>"file:"</code>, <code>"http:"</code> or <code>"mailto:"</code>) it is passed to the appropriate browser configured in the user system.- if it has no valid scheme (e.g. it's a local file path without the <code>"file:"</code> prefix), then {Wx::FileExists} and {Wx::DirExists} are used to test if it's a local file/directory; if it is, then the browser is called with the url parameter eventually prefixed by <code>"file:"</code>.- if it has no valid scheme and it's not a local file/directory, then <code>"http:"</code> is prepended and the browser is called.
+  # 
+  # - if it has a valid scheme (e.g. <code>"file:"</code>, <code>"http:"</code> or <code>"mailto:"</code>) it is passed to the appropriate browser configured in the user system.
+  # - if it has no valid scheme (e.g. it's a local file path without the <code>"file:"</code> prefix), then {Wx::FileExists} and {Wx::DirExists} are used to test if it's a local file/directory; if it is, then the browser is called with the url parameter eventually prefixed by <code>"file:"</code>.
+  # - if it has no valid scheme and it's not a local file/directory, then <code>"http:"</code> is prepended and the browser is called.
   # 
   # Returns true if the application was successfully launched.
   # For some configurations of the running user, the application which is launched to open the given URL may be URL-dependent (e.g. a browser may be used for local URLs while another one may be used for remote URLs).
@@ -201,7 +204,10 @@ module Wx
   # In some situations the current process and native CPU architecture may be different.
   # This returns the native CPU architecture regardless of the current process CPU architecture.
   # Common examples for CPU architecture differences are the following:
-  # - Win32 process in x64 Windows (WoW)- Win32 or x64 process on ARM64 Windows (WoW64)- x86_64 process on ARM64 macOS (Rosetta 2)
+  # 
+  # - Win32 process in x64 Windows (WoW)
+  # - Win32 or x64 process on ARM64 Windows (WoW64)
+  # - x86_64 process on ARM64 macOS (Rosetta 2)
   # 
   # The returned string may be empty if the CPU architecture couldn't be recognized.
   # @see get_cpu_architecture_name

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

@@ -34,7 +34,7 @@ module Wx
     
     # @overload initialize()
     #   Default constructor, you must call {Wx::VListBox#create} later.
-    #   @return [VListBox]
+    #   @return [Wx::VListBox]
     # @overload initialize(parent, id=Wx::StandardID::ID_ANY, pos=Wx::DEFAULT_POSITION, size=Wx::DEFAULT_SIZE, style=0, name=Wx::VListBoxNameStr)
     #   Normal constructor which calls {Wx::VListBox#create} internally.
     #   @param parent [Wx::Window] 
@@ -43,7 +43,7 @@ module Wx
     #   @param size [Array(Integer, Integer), Wx::Size] 
     #   @param style [Integer] 
     #   @param name [String] 
-    #   @return [VListBox]
+    #   @return [Wx::VListBox]
     def initialize(*args) end
     
     # Deletes all items from the control.

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

@@ -64,7 +64,7 @@ module Wx
   
     # @overload initialize()
     #   Default constructor, you must call {Wx::VScrolledWindow#create} later.
-    #   @return [VScrolledWindow]
+    #   @return [Wx::VScrolledWindow]
     # @overload initialize(parent, id=Wx::StandardID::ID_ANY, pos=Wx::DEFAULT_POSITION, size=Wx::DEFAULT_SIZE, style=0, name=Wx::PanelNameStr)
     #   This is the normal constructor, no need to call {Wx::VScrolledWindow#create} after using this constructor.
     #   {Wx::VSCROLL} is always automatically added to the style, there is no need to specify it explicitly.
@@ -74,7 +74,7 @@ module Wx
     #   @param size [Array(Integer, Integer), Wx::Size]  The initial window size.
     #   @param style [Integer]  The window style. There are no special style bits defined for this class.
     #   @param name [String]  The name for this window; usually not used.
-    #   @return [VScrolledWindow]
+    #   @return [Wx::VScrolledWindow]
     def initialize(*args) end
     
     # Same as the non-default constructor, but returns a status code: true if ok, false if the window couldn't be created.

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

@@ -13,7 +13,9 @@ module Wx
   # {Wx::Validator} is the base class for a family of validator classes that mediate between a class of control, and application data.
   # A validator has three major roles:
   # 
-  # - To transfer data from a C++ variable or own storage to and from a control.- To validate data in a control, and show an appropriate error message.- To filter events (such as keystrokes), thereby changing the behaviour of the associated control.
+  # - To transfer data from a C++ variable or own storage to and from a control.
+  # - To validate data in a control, and show an appropriate error message.
+  # - To filter events (such as keystrokes), thereby changing the behaviour of the associated control.
   # 
   # Validators can be plugged into controls dynamically.
   # To specify a default, "null" validator, use {Wx::DEFAULT_VALIDATOR}.
@@ -32,7 +34,7 @@ module Wx
   class Validator < EvtHandler
   
     # Constructor.
-    # @return [Validator]
+    # @return [Wx::Validator]
     def initialize; end
     
     # Returns the window associated with the validator.
@@ -43,9 +45,9 @@ module Wx
     # Associates a window with the validator.
     # This function is automatically called by wxWidgets when creating a {Wx::Window}-derived class instance which takes a {Wx::Validator} reference. Since wxWidgets 3.1.1, it can be overridden in custom validators in order to perform any one-time initialization or checks of the window when the validator is associated with it.
     # E.g. 
-    # ```
-    #   new wxTextCtrl(this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0,
-    #                  wxTextValidator(wxFILTER_ALPHA, &g_data.m_string));
+    # ```ruby
+    #   Wx::TextCtrl.new(self, Wx::ID_ANY, '', Wx::DEFAULT_POSITION, Wx::DEFAULT_SIZE, 0,
+    #                    Wx::TextValidator.new(Wx::FILTER_ALPHA))
     # ```
     #  will automatically link the {Wx::TextValidator} instance with the {Wx::TextCtrl} instance and call {Wx::Validator#set_window} method on the {Wx::TextValidator} object.
     # @param window [Wx::Window] 

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

@@ -8,92 +8,17 @@ module Wx
 
   # The {Wx::Variant} class represents a container for any type.
   # A variant's value can be changed at run time, possibly to a different type of value.
-  # As of wxWidgets 2.9.1, {Wx::GRID::GridCellAttr::AttrKind::Any} has become the preferred variant class. While most controls still use {Wx::Variant} in their interface, you can start using {Wx::GRID::GridCellAttr::AttrKind::Any} in your code because of an implicit conversion layer. See below for more information.
+  # In wxRuby Wx::Variant is the only available Wx variant class (unlike in C++) and almost exclusively for
+  # use in combination with the property grid classes (see the {Wx::PG} module).
   # 
-  # As standard, {Wx::Variant} can store values of type bool, {Wx::Char}, double, long, string, string list, time, date, void pointer, list of strings, and list of variants. However, an application can extend {Wx::Variant}'s capabilities by deriving from the class {Wx::VariantData} and using the {Wx::VariantData} form of the {Wx::Variant} constructor or assignment operator to assign this data to a variant. Actual values for user-defined types will need to be accessed via the {Wx::VariantData} object, unlike the case for basic data types where convenience functions such as {Wx::Variant#get_long} can be used.
-  # Under Microsoft Windows, three additional {Wx::VariantData}-derived classes  {Wx::VariantDataCurrency}, {Wx::VariantDataErrorCode} and {Wx::VariantDataSafeArray}  are available for interoperation with OLE VARIANT when using {Wx::AutomationObject}.
-  # Pointers to any {Wx::Object} derived class can also easily be stored in a {Wx::Variant}. {Wx::Variant} will then use wxWidgets' built-in RTTI system to set the type name (returned by {Wx::Variant#get_type}) and to perform type-safety checks at runtime.
-  # This class is useful for reducing the programming for certain tasks, such as an editor for different data types, or a remote procedure call protocol.
-  # An optional name member is associated with a {Wx::Variant}. This might be used, for example, in CORBA or OLE automation classes, where named parameters are required.
-  # Note that as of wxWidgets 2.7.1, {Wx::Variant} is reference counted. Additionally, the convenience macros DECLARE_VARIANT_OBJECT() and IMPLEMENT_VARIANT_OBJECT() were added so that adding (limited) support for conversion to and from {Wx::Variant} can be very easily implemented without modifying either {Wx::Variant} or the class to be stored by {Wx::Variant}. Since assignment operators cannot be declared outside the class, the shift left operators are used like this:
+  # By default Wx::Variant can store values of type bool, {Integer}, {Float}, {String}, {Time} (or {Date} / {DateTime}), {Array} of {String}, 
+  # {Array} of {Wx::Variant}, {Wx::Font}, {Wx::Colour} and {Wx::ColourPropertyValue}.
+  # In addition Wx::Variant can store any Ruby {Object}.
   # 
-  # ```
-  #   // in the header file
-  #   DECLARE_VARIANT_OBJECT(MyClass)
-  #   
-  #   // in the implementation file
-  #   IMPLEMENT_VARIANT_OBJECT(MyClass)
-  #   
-  #   // in the user code
-  #   wxVariant variant;
-  #   MyClass value;
-  #   variant << value;
-  #   
-  #   // or
-  #   value << variant;
-  # ```
-  # 
-  # For this to work, MyClass must derive from {Wx::Object}, implement the wxWidgets RTTI system and support the assignment operator and equality operator for itself. Ideally, it should also be reference counted to make copying operations cheap and fast. This can be most easily implemented using the reference counting support offered by {Wx::Object} itself. By default, wxWidgets already implements the shift operator conversion for a few of its drawing related classes:
-  # 
-  # ```
-  #   IMPLEMENT_VARIANT_OBJECT(wxColour)
-  #   IMPLEMENT_VARIANT_OBJECT(wxImage)
-  #   IMPLEMENT_VARIANT_OBJECT(wxIcon)
-  #   IMPLEMENT_VARIANT_OBJECT(wxBitmap)
-  # ```
-  # 
-  # Note that as of wxWidgets 2.9.0, {Wx::VariantData} no longer inherits from {Wx::Object} and {Wx::Variant} no longer uses the type-unsafe {Wx::List} class for list operations but the type-safe {Wx::VariantList} class. Also, {Wx::VariantData} now supports the Wx::VariantData#clone function for implementing the {Wx::Variant#unshare} function. Wx::VariantData#clone is implemented automatically by IMPLEMENT_VARIANT_OBJECT().
-  # Since {Wx::VariantData} no longer derives from {Wx::Object}, any code that tests the type of the data using {dynamic_cast} will require adjustment. You can use the macro {dynamic_cast_variant_data} with the same arguments as {dynamic_cast}, to use C++ RTTI type information instead of wxWidgets RTTI.
-  # 
-  # == wxVariant to wxAny Conversion Layer
-  # 
-  # {Wx::GRID::GridCellAttr::AttrKind::Any} is a more modern, template-based variant class. It is not directly compatible with {Wx::Variant}, but there is a transparent conversion layer.
-  # Following is an example how to use these conversions with {Wx::PG::PropertyGrid}'s property class {Wx::PG::PGProperty} (which currently uses {Wx::Variants} both internally and in the public API):
-  # 
-  # ```
-  #   // Get property value as wxAny instead of wxVariant
-  #   wxAny value = property->GetValue();
-  #   
-  #   // Do something with it
-  #   DoSomethingWithString(value.As<wxString>());
-  #   
-  #   // Write back new value to property
-  #   value = "New Value";
-  #   property->SetValue(value);
-  # ```
-  # 
-  # Some caveats: 
-  # - In {Wx::GRID::GridCellAttr::AttrKind::Any}, there are no separate types for handling integers of different sizes, so converting {Wx::GRID::GridCellAttr::AttrKind::Any} with 'long long' value will yield {Wx::Variant} of "long" type when the value is small enough to fit in without overflow. Otherwise, variant type "longlong" is used. Also note that {Wx::GRID::GridCellAttr::AttrKind::Any} holding unsigned integer will always be converted to "ulonglong" {Wx::Variant} type.
-  # 
-  # - Unlike {Wx::Variant}, {Wx::GRID::GridCellAttr::AttrKind::Any} does not store a (rarely needed) name string.
-  # 
-  # - Because of implicit conversion of {Wx::Variant} to {Wx::GRID::GridCellAttr::AttrKind::Any}, {Wx::GRID::GridCellAttr::AttrKind::Any} cannot usually contain value of type {Wx::Variant}. In other words, any.CheckType<{Wx::Variant}>() can never return true.
-  # 
-  # Supplied conversion functions will automatically work with all built-in {Wx::Variant} types, and also with all user-specified types generated using IMPLEMENT_VARIANT_OBJECT(). For hand-built {Wx::VariantData} classes, you will need to use supplied macros in a following manner:
-  # 
-  # ```
-  #   // Declare wxVariantData for data type Foo
-  #   class wxVariantDataFoo: public wxVariantData
-  #   {
-  #   public:
-  #       // interface
-  #       // ...
-  #   
-  #       DECLARE_WXANY_CONVERSION()
-  #   protected:
-  #       // data storage etc
-  #       // ...
-  #   };
-  #   
-  #   IMPLEMENT_TRIVIAL_WXANY_CONVERSION(Foo, wxVariantDataFoo)
-  # ```
-  # 
-  # === 
-  # 
-  # Category:  Data Structures
-  # @see Wx::VariantData
-  # @see  Wx::GRID::GridCellAttr::AttrKind::Any 
+  # An optional name member is associated with a Wx::Variant.
   # 
+  # In wxRuby Wx::Variant also provides the standard conversion methods #to_i, #to_s and #to_f for supported
+  # value types. In case of incompatible value types these methods will raise a {TypeError} exception.
   # 
   # 
   # @note This class is <b>untracked</b> and should not be derived from nor instances extended!
@@ -192,62 +117,62 @@ module Wx
     
     # @overload initialize()
     #   Default constructor.
-    #   @return [Variant]
+    #   @return [Wx::Variant]
     # @overload initialize(data, name=(''))
     #   Constructs a variant directly with a {Wx::VariantData} object.
     #   {Wx::Variant} will take ownership of the {Wx::VariantData} and will not increase its reference count.
     #   @param data [Object] 
     #   @param name [String] 
-    #   @return [Variant]
+    #   @return [Wx::Variant]
     # @overload initialize(variant)
     #   Constructs a variant from another variant by increasing the reference count.
     #   @param variant [nil,String,Integer,Float,Time,Wx::Font,Wx::Colour,Wx::Variant,Array<WxVariant>,Array<String>,ObjectWx::PG::ColourPropertyValue] 
-    #   @return [Variant]
+    #   @return [Wx::Variant]
     # @overload initialize(value, name=(''))
     #   Constructs a variant from a string.
     #   @param value [String] 
     #   @param name [String] 
-    #   @return [Variant]
+    #   @return [Wx::Variant]
     # @overload initialize(value, name=(''))
     #   Constructs a variant from a long.
     #   @param value [Integer] 
     #   @param name [String] 
-    #   @return [Variant]
+    #   @return [Wx::Variant]
     # @overload initialize(value, name=(''))
     #   Constructs a variant from a bool.
     #   @param value [true,false] 
     #   @param name [String] 
-    #   @return [Variant]
+    #   @return [Wx::Variant]
     # @overload initialize(value, name=(''))
     #   Constructs a variant from a double.
     #   @param value [Float] 
     #   @param name [String] 
-    #   @return [Variant]
+    #   @return [Wx::Variant]
     # @overload initialize(value, name=(''))
     #   Constructs a variant from a {Wx::LongLong}.
     #   @param value [Integer] 
     #   @param name [String] 
-    #   @return [Variant]
+    #   @return [Wx::Variant]
     # @overload initialize(value, name=(''))
     #   Constructs a variant from a {Wx::ULongLong}.
     #   @param value [Integer] 
     #   @param name [String] 
-    #   @return [Variant]
+    #   @return [Wx::Variant]
     # @overload initialize(value, name=(''))
     #   Constructs a variant from a list of variants.
     #   @param value [Array<Wx::Variant>] 
     #   @param name [String] 
-    #   @return [Variant]
+    #   @return [Wx::Variant]
     # @overload initialize(val, name=(''))
     #   Constructs a variant from a {Wx::DateTime}.
     #   @param val [Time,Date,DateTime] 
     #   @param name [String] 
-    #   @return [Variant]
+    #   @return [Wx::Variant]
     # @overload initialize(val, name=(''))
     #   Constructs a variant from a {Wx::ArrayString}.
     #   @param val [Array<String>] 
     #   @param name [String] 
-    #   @return [Variant]
+    #   @return [Wx::Variant]
     def initialize(*args) end
     
     # Returns the string array value.
@@ -303,9 +228,21 @@ module Wx
     
     # Returns the value type as a string.
     # The built-in types are:
-    # - "bool"- "char"- "datetime"- "double"- "list"- "long"- "longlong"- "string"- "ulonglong"- "arrstring"- "void*"
     # 
-    # If the variant is null, the value type returned is the string "null" (not the empty string).
+    # - "bool"
+    # - "char"
+    # - "datetime"
+    # - "double"
+    # - "list"
+    # - "long"
+    # - "longlong"
+    # - "string"
+    # - "ulonglong"
+    # - "arrstring"
+    # 
+    # If the variant is null, the value type returned is the string "null" (not the empty string). 
+    #         
+    # If the variant contains an arbitrary Ruby {Object}, the value type returned is the result of `variant.get_object.class.name`.
     # @return [String]
     def get_type; end
     alias_method :type, :get_type