wxruby3 0.9.2-x64-mingw-ucrt → 0.9.4-x64-mingw-ucrt

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

@@ -23,6 +23,7 @@ module Wx
   EVT_TREEBOOK_NODE_EXPANDED = 10089
   
   # This class is an extension of the {Wx::Notebook} class that allows a tree structured set of pages to be shown in a control.
+  # 
   # A classic example is a netscape preferences dialog that shows a tree of preference sections on the left and select section page on the right.
   # To use the class simply create it and populate with pages using {Wx::Treebook#insert_page}, {Wx::Treebook#insert_sub_page}, {Wx::Treebook#add_page}, {Wx::Treebook#add_sub_page}.
   # If your tree is no more than 1 level in depth then you could simply use {Wx::Treebook#add_page} and {Wx::Treebook#add_sub_page} to sequentially populate your tree by adding at every step a page or a subpage to the end of the tree.
@@ -67,6 +68,7 @@ module Wx
     def initialize(*args) end
     
     # Adds a new page.
+    # 
     # The page is placed at the topmost level after all other pages. NULL could be specified for page to create an empty page.
     # @param page [Wx::Window] 
     # @param text [String] 
@@ -76,6 +78,7 @@ module Wx
     def add_page(page, text, bSelect=false, imageId=Wx::NOT_FOUND) end
     
     # Adds a new child-page to the last top-level page.
+    # 
     # NULL could be specified for page to create an empty page.
     # @param page [Wx::Window] 
     # @param text [String] 
@@ -90,6 +93,7 @@ module Wx
     def collapse_node(pageId) end
     
     # Creates a treebook control.
+    # 
     # See {Wx::Treebook#initialize} for the description of the parameters.
     # @param parent [Wx::Window] 
     # @param id [Integer] 
@@ -101,12 +105,14 @@ module Wx
     def create(parent, id, pos=Wx::DEFAULT_POSITION, size=Wx::DEFAULT_SIZE, style=Wx::BK_DEFAULT, name=('')) end
     
     # Deletes the page at the specified position and all its children.
+    # 
     # Could trigger page selection change in a case when selected page is removed. In that case its parent is selected (or the next page if no parent).
     # @param pagePos [Integer] 
     # @return [Boolean]
     def delete_page(pagePos) end
     
     # Expands (collapses) the pageId node.
+    # 
     # Returns the previous state. May generate page changing events (if selected page is under the collapsed branch, then its parent is autoselected).
     # @param pageId [Integer] 
     # @param expand [Boolean] 
@@ -120,6 +126,7 @@ module Wx
     alias_method :page_parent, :get_page_parent
     
     # Returns the currently selected page, or {Wx::NOT_FOUND} if none was selected.
+    # 
     # <div class="wxrb-note">
     # <b>Note:</b>
     # <p>This method may return either the previously or newly selected page when called from the EVT_TREEBOOK_PAGE_CHANGED() handler depending on the platform and so {Wx::BookCtrlEvent#get_selection} should be used instead in this case. 
@@ -130,6 +137,7 @@ module Wx
     alias_method :selection, :get_selection
     
     # Inserts a new page just before the page indicated by pagePos.
+    # 
     # The new page is placed before pagePos page and on the same level. NULL could be specified for page to create an empty page.
     # @param pagePos [Integer] 
     # @param page [Wx::Window] 
@@ -140,6 +148,7 @@ module Wx
     def insert_page(pagePos, page, text, bSelect=false, imageId=Wx::NOT_FOUND) end
     
     # Inserts a sub page under the specified page.
+    # 
     # NULL could be specified for page to create an empty page.
     # @param pagePos [Integer] 
     # @param page [Wx::Window] 

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

@@ -7,6 +7,7 @@
 module Wx
 
   # {Wx::UIActionSimulator} is a class used to simulate user interface actions such as a mouse click or a key press.
+  # 
   # Common usage for this class would be to provide playback and record (aka macro recording) functionality for users, or to drive unit tests by simulating user sessions.
   # See the wxUIActionSimulator Sample for an example of using this class.
   # 
@@ -66,6 +67,7 @@ module Wx
     def mouse_drag_drop(x1, y1, x2, y2, button=Wx::MouseButton::MOUSE_BTN_LEFT) end
     
     # Press a key.
+    # 
     # If you are using modifiers then it needs to be paired with an identical KeyUp or the modifiers will not be released (MSW and macOS).
     # @param keycode [Integer]  Key to operate on, as an integer. It is interpreted as a {Wx::KeyCode}.
     # @param modifiers [Integer]  A combination of {Wx::KeyModifier} flags to be pressed with the given keycode.
@@ -85,6 +87,7 @@ module Wx
     def char(keycode, modifiers=Wx::KeyModifier::MOD_NONE) end
     
     # Simulate selection of an item with the given text.
+    # 
     # This method selects an item in the currently focused {Wx::Choice}, {Wx::ComboBox}, {Wx::ListBox} and similar controls. It does it by simulating keyboard events, so the behaviour should be the same as if the item was really selected by the user.
     # Notice that the implementation of this method uses {yield} and so events can be dispatched from it.
     # 
@@ -94,6 +97,7 @@ module Wx
     def select(text) end
     
     # Emulate typing in the keys representing the given string.
+    # 
     # Currently only the ASCII letters are universally supported. Digits and punctuation characters can be used with the standard QWERTY (US) keyboard layout but may not work with other layouts.
     # @param text [String]  The string, containing only US ASCII characters, to type.
     # @return [Boolean]

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

@@ -6,7 +6,28 @@
 
 module Wx
 
+  # Strip '&' characters.
+  # 
+  Strip_Mnemonics = 1
+  
+  # Strip everything after '\t'.
+  # 
+  Strip_Accel = 2
+  
+  # Strip everything looking like CJK mnemonic.
+  # 
+  Strip_CJKMnemonics = 4
+  
+  # Strip both mnemonics and accelerators.
+  # 
+  Strip_All = 3
+  
+  # Strip everything from menu item labels.
+  # 
+  Strip_Menu = 7
+  
   # Changes the cursor to the given cursor for all windows in the application.
+  # 
   # Use {end_busy_cursor} to revert the cursor back to its previous state. These two calls can be nested, and a counter ensures that only the outer calls take effect.
   # @see is_busy
   # @see  Wx::BusyCursor
@@ -15,6 +36,7 @@ module Wx
   def self.begin_busy_cursor(cursor=Wx::HOURGLASS_CURSOR) end
   
   # Changes the cursor back to the original cursor, for all windows in the application.
+  # 
   # Use with {begin_busy_cursor}.
   # @see is_busy
   # @see  Wx::BusyCursor
@@ -23,22 +45,23 @@ module Wx
   
   # Returns true if between two {begin_busy_cursor} and {end_busy_cursor} calls.
   # 
+  # 
   # @see Wx::BusyCursor.
   # @return [Boolean]
   def self.is_busy; end
   
   # Ring the system bell.
+  # 
   # <div class="wxrb-note">
   # <b>Note:</b>
   # <p>This function is categorized as a GUI one and so is not thread-safe.
   # </p>
   # </div>
-  # 
-  # Include file: \#include <wx/utils.h>
   # @return [void]
   def self.bell; end
   
   # Shows a message box with the information about the wxWidgets build used, including its version, most important build parameters and the version of the underlying GUI toolkit.
+  # 
   # This is mainly used for diagnostic purposes and can be invoked by Ctrl-Alt-middle clicking on any {Wx::Window} which doesn't otherwise handle this event.
   # @see get_library_version_info
   # @param parent [Wx::Window] 
@@ -47,11 +70,13 @@ module Wx
   
   # Get wxWidgets version information.
   # 
+  # 
   # @see Wx::VersionInfo
   # @return [Wx::VersionInfo]
   def self.get_library_version_info; end
   
   # 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 WXGTK, this function can be only used with modifier keys ({Wx::KeyCode::K_ALT}, {Wx::KeyCode::K_CONTROL} and {Wx::KeyCode::K_SHIFT}) when not using X11 backend currently.
@@ -64,17 +89,20 @@ module Wx
   def self.get_mouse_position; end
   
   # Returns the current state of the mouse.
+  # 
   # Returns a {Wx::MouseState} instance that contains the current position of the mouse pointer in screen coordinates, as well as boolean values indicating the up/down status of the mouse buttons and the modifier keys.
   # @return [Wx::MouseState]
   def self.get_mouse_state; end
   
   # This function enables or disables all top level windows.
+  # 
   # It is used by {safe_yield}.
   # @param enable [Boolean] 
   # @return [void]
   def self.enable_top_level_windows(enable=true) end
   
   # Find the deepest window at the given mouse position in screen coordinates, returning the window if found, or NULL if not.
+  # 
   # This function takes child windows at the given position into account even if they are disabled. The hidden children are however skipped by it.
   # @param pt [Array(Integer, Integer), Wx::Point] 
   # @return [Wx::Window]
@@ -93,6 +121,7 @@ module Wx
   def self.register_id(id) end
   
   # Opens the document in the application associated with the files of this type.
+  # 
   # The flags parameter is currently not used
   # Returns true if the application was successfully launched.
   # @see launch_default_browser
@@ -103,6 +132,7 @@ module Wx
   def self.launch_default_application(document, flags=0) end
   
   # Opens the url in user's default browser.
+  # 
   # 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:
@@ -118,8 +148,6 @@ module Wx
   # <p>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).
   # </p>
   # </div>
-  # 
-  # Include file: \#include <wx/utils.h>
   # @see launch_default_application
   # @see  execute
   # @param url [String] 
@@ -127,10 +155,18 @@ module Wx
   # @return [Boolean]
   def self.launch_default_browser(url, flags=0) end
   
+  # Strips any menu codes from str and returns the result.
+  # 
+  # By default, the functions strips both the mnemonics character (<code>'&'</code>) which is used to indicate a keyboard shortkey, and the accelerators, which are used only in the menu items and are separated from the main text by the <code>\t</code> (TAB) character. By using flags of {Wx::Strip_Mnemonics} or {Wx::Strip_Accel} to strip only the former or the latter part, respectively.
+  # Notice that in most cases {Wx::MenuItem.get_label_from_text} or {Wx::Control#get_label_text} can be used instead.
+  # @param str [String] 
+  # @param flags [Integer] 
+  # @return [String]
+  def self.strip_menu_codes(str, flags=Wx::Strip_All) end
+  
   # Copies the user's email address into the supplied buffer, by concatenating the values returned by {get_full_host_name} and {get_user_id}.
-  # true if successful, false otherwise.
   # 
-  # Include file: \#include <wx/utils.h>
+  # true if successful, false otherwise.
   # @return [String]
   def self.get_email_address; end
   
@@ -140,27 +176,29 @@ module Wx
   
   # Return the (current) user's home directory.
   # 
+  # 
   # @see get_user_home
   # @see  Wx::StandardPaths
   # @return [String]
   def self.get_home_dir; end
   
   # Copies the current host machine's name into the supplied buffer.
+  # 
   # Please note that the returned name is not fully qualified, i.e. it does not include the domain name.
   # The hostname if successful or an empty string otherwise.
-  # 
-  # Include file: \#include <wx/utils.h>
   # @see get_full_host_name
   # @return [String]
   def self.get_host_name; end
   
   # Returns the FQDN (fully qualified domain host name) or an empty string on error.
   # 
+  # 
   # @see get_host_name
   # @return [String]
   def self.get_full_host_name; end
   
   # Returns the home directory for the given user.
+  # 
   # If the user is empty (default value), this function behaves like {get_home_dir} (i.e. returns the current user home directory).
   # If the home directory couldn't be determined, an empty string is returned.
   # @param user [String] 
@@ -168,24 +206,23 @@ module Wx
   def self.get_user_home(user=('')) end
   
   # This function returns the "user id" also known as "login name" under Unix (i.e.
+  # 
   # something like "jsmith"). It uniquely identifies the current user (on this system). Under Windows or NT, this function first looks in the environment variables USER and LOGNAME; if neither of these is found, the entry <b>UserId</b> in the <b>wxWidgets</b> section of the WIN.INI file is tried.
   # The login name if successful or an empty string otherwise.
-  # 
-  # Include file: \#include <wx/utils.h>
   # @see get_user_name
   # @return [String]
   def self.get_user_id; end
   
   # This function returns the full user name (something like "Mr. John Smith").
+  # 
   # Under Windows or NT, this function looks for the entry UserName in the wxWidgets section of the WIN.INI file. If PenWindows is running, the entry Current in the section User of the PENWIN.INI file is used.
   # The full user name if successful or an empty string otherwise.
-  # 
-  # Include file: \#include <wx/utils.h>
   # @see get_user_id
   # @return [String]
   def self.get_user_name; end
   
   # Returns the string containing the description of the current platform in a user-readable form.
+  # 
   # For example, this function may return strings like "Windows 10 (build 10240), 64-bit edition" or "Linux 4.1.4 i386".
   # @see get_os_version
   # @return [String]
@@ -193,6 +230,7 @@ module Wx
   
   # Returns true if the version of the operating system on which the program is running under is the same or later than the given version.
   # 
+  # 
   # @see get_os_version
   # @see  Wx::PlatformInfo
   # @param majorVsn [Integer] 
@@ -202,6 +240,7 @@ module Wx
   def self.check_os_version(majorVsn, minorVsn=0, microVsn=0) end
   
   # Returns true if the operating system the program is running under is 64 bit.
+  # 
   # The check is performed at run-time and may differ from the value available at compile-time (at compile-time you can just check if <code>sizeof(void*) == 8</code>) since the program could be running in emulation mode or in a mixed 32/64 bit system.
   # 
   # <div class="wxrb-note">
@@ -209,18 +248,18 @@ module Wx
   # <p>This function is not 100% reliable on some systems given the fact that there isn't always a standard way to do a reliable check on the OS bitness.
   # </p>
   # </div>
-  # 
-  # Include file: \#include <wx/utils.h>
   # @return [Boolean]
   def self.is_platform64bit; end
   
   # Returns true if the current platform is little endian (instead of big endian).
+  # 
   # The check is performed at run-time.
   # @see Byte Order Functions and Macros
   # @return [Boolean]
   def self.is_platform_little_endian; end
   
   # Returns the CPU architecture name.
+  # 
   # This can be, for example, "x86_64", "arm64", or "i86pc". The name for the same CPU running on the same hardware can vary across operating systems.
   # The returned string may be empty if the CPU architecture couldn't be recognized.
   # @see get_native_cpu_architecture_name
@@ -228,6 +267,7 @@ module Wx
   def self.get_cpu_architecture_name; end
   
   # 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:
   # 
@@ -241,6 +281,7 @@ module Wx
   def self.get_native_cpu_architecture_name; end
   
   # This function shuts down or reboots the computer depending on the value of the flags.
+  # 
   # <div class="wxrb-note">
   # <b>Note:</b>
   # <p>Note that performing the shutdown requires the corresponding access rights (superuser under Unix, SE_SHUTDOWN privilege under Windows) and that this function is only implemented under Unix and MSW.
@@ -248,8 +289,6 @@ module Wx
   # </div>
   # 
   # true on success, false if an error occurred.
-  # 
-  # Include file: \#include <wx/utils.h>
   # @param flags [Integer]  One of {Wx::SHUTDOWN_POWEROFF}, {Wx::SHUTDOWN_REBOOT} or {Wx::SHUTDOWN_LOGOFF} (currently implemented only for MSW) possibly combined with {Wx::SHUTDOWN_FORCE} which forces shutdown under MSW by forcefully terminating all the applications. As doing this can result in a data loss, this flag shouldn't be used unless really necessary.
   # @return [Boolean]
   def self.shutdown(flags=Wx::SHUTDOWN_POWEROFF) end

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

@@ -7,6 +7,7 @@
 module Wx
 
   # {Wx::VListBox} is a {Wx::ListBox}-like control with the following two main differences from a regular {Wx::ListBox}: it can have an arbitrarily huge number of items because it doesn't store them itself but uses the {Wx::VListBox#on_draw_item} callback to draw them (so it is a virtual listbox) and its items can have variable height as determined by {Wx::VListBox#on_measure_item} (so it is also a listbox with the lines of variable height).
+  # 
   # Also, as a consequence of its virtual nature, it doesn't have any methods to append or insert items in it as it isn't necessary to do it: you just have to call {Wx::VListBox#set_item_count} to tell the control how many items it should display. Of course, this also means that you will never use this class directly because it has pure virtual functions, but will need to derive your own class from it (for example, {Wx::HTML::HtmlListBox}).
   # However it emits the same events as {Wx::ListBox} and the same event macros may be used with it. Since {Wx::VListBox} does not store its items itself, the events will only contain the index, not any contents such as the string of an item.
   # 
@@ -19,11 +20,13 @@ module Wx
   
     # @overload set_margins(pt)
     #   Set the margins: horizontal margin is the distance between the window border and the item contents while vertical margin is half of the distance between items.
+    #   
     #   By default both margins are 0.
     #   @param pt [Array(Integer, Integer), Wx::Point] 
     #   @return [void]
     # @overload set_margins(x, y)
     #   Set the margins: horizontal margin is the distance between the window border and the item contents while vertical margin is half of the distance between items.
+    #   
     #   By default both margins are 0.
     #   @param x [Integer] 
     #   @param y [Integer] 
@@ -50,6 +53,7 @@ module Wx
     def clear; end
     
     # Creates the control.
+    # 
     # To finish creating it you also should call {Wx::VListBox#set_item_count} to let it know about the number of items it contains.
     # The only special style which may be used with {Wx::VListBox} is {Wx::LB_MULTIPLE} which indicates that the listbox should support multiple selection.
     # true on success or false if the control couldn't be created.
@@ -63,6 +67,7 @@ module Wx
     def create(parent, id=Wx::StandardID::ID_ANY, pos=Wx::DEFAULT_POSITION, size=Wx::DEFAULT_SIZE, style=0, name=Wx::V_LIST_BOX_NAME_STR) end
     
     # Deselects all the items in the listbox.
+    # 
     # This method is only valid for multi selection listboxes.
     # true if any items were changed, i.e. if there had been any selected items before, or false if all the items were already deselected.
     # @see Wx::VListBox#select_all
@@ -72,12 +77,14 @@ module Wx
     
     # Get the number of items in the control.
     # 
+    # 
     # @see Wx::VListBox#set_item_count 
     # @return [Integer]
     def get_item_count; end
     alias_method :item_count, :get_item_count
     
     # Returns the margins used by the control.
+    # 
     # The x field of the returned point is the horizontal margin and the y field is the vertical one.
     # @see Wx::VListBox#set_margins 
     # @return [Wx::Point]
@@ -85,6 +92,7 @@ module Wx
     alias_method :margins, :get_margins
     
     # Returns the rectangle occupied by this item in physical coordinates.
+    # 
     # If the item is not currently visible, returns an empty rectangle.
     # @param item [Integer] 
     # @return [Wx::Rect]
@@ -92,6 +100,7 @@ module Wx
     alias_method :item_rect, :get_item_rect
     
     # Returns the number of the items currently selected.
+    # 
     # It is valid for both single and multi selection controls. In the former case it may only return 0 or 1 however.
     # @see Wx::VListBox#is_selected
     # @see  Wx::VListBox#get_first_selected
@@ -106,6 +115,7 @@ module Wx
     alias_method :selection, :get_selection
     
     # Returns the background colour used for the selected cells.
+    # 
     # By default the standard system colour is used.
     # @see Wx::SystemSettings.get_colour
     # @see  Wx::VListBox#set_selection_background 
@@ -119,6 +129,7 @@ module Wx
     alias_method :has_multiple_selection?, :has_multiple_selection
     
     # Returns true if this item is the current one, false otherwise.
+    # 
     # The current item is always the same as selected one for the single selection listbox and in this case this method is equivalent to {Wx::VListBox#is_selected} but they are different for multi selection listboxes where many items may be selected but only one (at most) is current.
     # @param item [Integer] 
     # @return [Boolean]
@@ -132,6 +143,7 @@ module Wx
     alias_method :selected?, :is_selected
     
     # Selects or deselects the specified item which must be valid (i.e. not equal to {Wx::NOT_FOUND}).
+    # 
     # true if the items selection status has changed or false otherwise.
     # 
     # This function is only valid for the multiple selection listboxes, use {Wx::VListBox#set_selection} for the single selection ones.
@@ -141,6 +153,7 @@ module Wx
     def select(item, select=true) end
     
     # Selects all the items in the listbox.
+    # 
     # true if any items were changed, i.e. if there had been any unselected items before, or false if all the items were already selected.
     # 
     # This method is only valid for multi selection listboxes.
@@ -150,6 +163,7 @@ module Wx
     def select_all; end
     
     # Selects all items in the specified range which may be given in any order.
+    # 
     # true if the items selection status has changed or false otherwise.
     # 
     # This method is only valid for multi selection listboxes.
@@ -161,6 +175,7 @@ module Wx
     def select_range(from, to) end
     
     # Set the number of items to be shown in the control.
+    # 
     # This is just a synonym for {Wx::VScrolledWindow#set_row_count}.
     # @param count [Integer] 
     # @return [void]
@@ -168,6 +183,7 @@ module Wx
     alias_method :item_count=, :set_item_count
     
     # Set the selection to the specified item, if it is -1 the selection is unset.
+    # 
     # The selected item will be automatically scrolled into view if it isn't currently visible.
     # This method may be used both with single and multiple selection listboxes.
     # @param selection [Integer] 
@@ -176,6 +192,7 @@ module Wx
     alias_method :selection=, :set_selection
     
     # Sets the colour to be used for the selected cells background.
+    # 
     # The background of the standard cells may be changed by simply calling {Wx::Window#set_background_colour}.
     # 
     # <div class="wxrb-note">
@@ -190,6 +207,7 @@ module Wx
     alias_method :selection_background=, :set_selection_background
     
     # Toggles the state of the specified item, i.e. selects it if it was unselected and deselects it if it was selected.
+    # 
     # This method is only valid for multi selection listboxes.
     # @see Wx::VListBox#select 
     # @param item [Integer] 
@@ -200,6 +218,7 @@ module Wx
     protected
     
     # The derived class must implement this function to actually draw the item with the given index on the provided DC.
+    # 
     # TodoChange this function signature to non-const.
     # @param dc [Wx::DC]  The device context to use for drawing.
     # @param rect [Wx::Rect]  The bounding rectangle for the item being drawn (DC clipping region is set to this rectangle before calling this function).
@@ -208,6 +227,7 @@ module Wx
     def on_draw_item(dc, rect, n) end
     
     # This method is used to draw the item's background and, maybe, a border around it.
+    # 
     # The base class version implements a reasonable default behaviour which consists in drawing the selected item with the standard background colour and drawing a border around the item if it is either selected or current.
     # TodoChange this function signature to non-const.
     # @param dc [Wx::DC] 
@@ -217,6 +237,7 @@ module Wx
     def on_draw_background(dc, rect, n) end
     
     # This method may be used to draw separators between the lines.
+    # 
     # The rectangle passed to it may be modified, typically to deflate it a bit before passing to {Wx::VListBox#on_draw_item}.
     # The base class version of this method doesn't do anything.
     # 

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

@@ -7,6 +7,7 @@
 module Wx
 
   # In the name of this class, "V" may stand for "variable" because it can be used for scrolling rows of variable heights; "virtual", because it is not necessary to know the heights of all rows in advance  only those which are shown on the screen need to be measured; or even "vertical", because this class only supports scrolling vertically.
+  # 
   # In any case, this is a generalization of {Wx::Scrolled} which can be only used when all rows have the same heights. It lacks some other {Wx::Scrolled} features however, notably it can't scroll specific pixel sizes of the window or its exact client area size.
   # To use this class, you need to derive from it and implement the {Wx::VScrolledWindow#on_get_row_height} pure virtual method. You also must call {Wx::VScrolledWindow#set_row_count} to let the base class know how many rows it should display, but from that moment on the scrolling is handled entirely by {Wx::VScrolledWindow}. You only need to draw the visible part of contents in your <code>OnPaint()</code> method as usual. You should use {Wx::VScrolledWindow#get_visible_rows_begin} and {Wx::VScrolledWindow#get_visible_rows_end} to select the lines to display. Note that the device context origin is not shifted so the first visible row always appears at the point (0, 0) in physical as well as logical coordinates.
   # 
@@ -65,6 +66,7 @@ module Wx
     #   @return [Wx::VScrolledWindow]
     # @overload initialize(parent, id=Wx::StandardID::ID_ANY, pos=Wx::DEFAULT_POSITION, size=Wx::DEFAULT_SIZE, style=0, name=Wx::PANEL_NAME_STR)
     #   This is the normal constructor, no need to call {Wx::VScrolledWindow#create} after using this constructor.
+    #   
     #   <div class="wxrb-note">
     #   <b>Note:</b>
     #   <p>{Wx::VSCROLL} is always automatically added to the style, there is no need to specify it explicitly.
@@ -80,6 +82,7 @@ module Wx
     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.
+    # 
     # Just as with the constructor, the {Wx::VSCROLL} style is always used, there is no need to specify it explicitly.
     # @param parent [Wx::Window] 
     # @param id [Integer] 
@@ -92,6 +95,7 @@ module Wx
     
     # Returns the number of rows the target window contains.
     # 
+    # 
     # @see Wx::VScrolledWindow#set_row_count 
     # @return [Integer]
     def get_row_count; end
@@ -103,6 +107,7 @@ module Wx
     alias_method :visible_rows_begin, :get_visible_rows_begin
     
     # Returns the index of the last visible row based on the scroll position.
+    # 
     # This includes the last row even if it is only partially visible.
     # @return [Integer]
     def get_visible_rows_end; end
@@ -131,12 +136,14 @@ module Wx
     def scroll_row_pages(pages) end
     
     # Scroll by the specified number of rows which may be positive (to scroll down) or negative (to scroll up).
+    # 
     # true if the window was scrolled, false otherwise (for example, if we're trying to scroll down but we are already showing the last row).
     # @param rows [Integer] 
     # @return [Boolean]
     def scroll_rows(rows) end
     
     # Scroll to the specified row.
+    # 
     # It will become the first visible row in the window.
     # true if we scrolled the window, false if nothing was done.
     # @param row [Integer] 
@@ -144,6 +151,7 @@ module Wx
     def scroll_to_row(row) end
     
     # Set the number of rows the window contains.
+    # 
     # The derived class must provide the heights for all rows with indices up to the one given here in it's {Wx::VScrolledWindow#on_get_row_height} implementation.
     # @see Wx::VScrolledWindow#get_row_count 
     # @param rowCount [Integer] 
@@ -152,6 +160,7 @@ module Wx
     alias_method :row_count=, :set_row_count
     
     # Translates the logical coordinate given to the current device coordinate.
+    # 
     # For example, if the window is scrolled 10 units and each scroll unit represents 10 device units (which may not be the case since this class allows for variable scroll unit sizes), a call to this function with a coordinate of 15 will return -85.
     # @see Wx::VScrolledWindow#calc_unscrolled_position 
     # @param coord [Integer] 
@@ -159,6 +168,7 @@ module Wx
     def calc_scrolled_position(coord) end
     
     # Translates the device coordinate given to the corresponding logical coordinate.
+    # 
     # For example, if the window is scrolled 10 units and each scroll unit represents 10 device units (which may not be the case since this class allows for variable scroll unit sizes), a call to this function with a coordinate of 15 will return 115.
     # @see Wx::VScrolledWindow#calc_scrolled_position 
     # @param coord [Integer] 
@@ -166,6 +176,7 @@ module Wx
     def calc_unscrolled_position(coord) end
     
     # With physical scrolling on (when this is true), the device origin is changed properly when a {Wx::PaintDC} is prepared, children are actually moved and laid out properly, and the contents of the window (pixels) are actually moved.
+    # 
     # When this is false, you are responsible for repainting any invalidated areas of the window yourself to account for the new scroll position.
     # @param scrolling [Boolean] 
     # @return [void]
@@ -173,6 +184,7 @@ module Wx
     
     # This function will return the target window this helper class is currently scrolling.
     # 
+    # 
     # @see Wx::VScrolledWindow#set_target_window 
     # @return [Wx::Window]
     def get_target_window; end
@@ -184,6 +196,7 @@ module Wx
     alias_method :visible_begin, :get_visible_begin
     
     # Returns the index of the last visible unit based on the scroll position.
+    # 
     # This includes the last unit even if it is only partially visible.
     # @return [Integer]
     def get_visible_end; end
@@ -200,6 +213,7 @@ module Wx
     def refresh_all; end
     
     # Normally the window will scroll itself, but in some rare occasions you might want it to scroll (part of) another window (e.g.
+    # 
     # a child of it in order to scroll only a portion the area between the scrollbars like a spreadsheet where only the cell area will move).
     # @see Wx::VScrolledWindow#get_target_window 
     # @param target [Wx::Window] 
@@ -212,6 +226,7 @@ module Wx
     def update_scrollbar; end
     
     # Returns the virtual scroll unit under the device unit given accounting for scroll position or {Wx::NOT_FOUND} if none (i.e.
+    # 
     # if it is below the last item).
     # @param coord [Integer] 
     # @return [Integer]

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

@@ -11,6 +11,7 @@ module Wx
   DEFAULT_VALIDATOR = nil
   
   # {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.
@@ -37,25 +38,20 @@ module Wx
     # @return [Wx::Validator]
     def initialize; end
     
+    # All validator classes must implement the {Wx::Validator#clone} function, which returns an identical copy of itself.
+    # 
+    # This is because validators are passed to control constructors as references which must be copied. Unlike objects such as pens and brushes, it does not make sense to have a reference counting scheme to do this cloning because all validators should have separate data.
+    # This base function returns NULL.
+    # @return [Wx::Object]
+    def clone; end
+    
     # Returns the window associated with the validator.
     # @return [Wx::Window]
     def get_window; end
     alias_method :window, :get_window
     
-    # 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. 
-    # ```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] 
-    # @return [void]
-    def set_window(window) end
-    alias_method :window=, :set_window
-    
     # This overridable function is called when the value in the associated window must be validated.
+    # 
     # false if the value in the window is not valid; you may pop up an error dialog.
     # @param parent [Wx::Window]  The parent of the window associated with the validator.
     # @return [Boolean]