wxruby3 0.9.0.pre.beta.8-x64-mingw-ucrt

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

@@ -0,0 +1,224 @@
+# :stopdoc:
+# This file is automatically generated by the WXRuby3 documentation 
+# generator. Do not alter this file.
+# :startdoc:
+
+
+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.
+  # === 
+  # 
+  # Category:  {Wx::Controls}
+  # @see Wx::HTML::SimpleHtmlListBox
+  # @see  Wx::HTML::HtmlListBox 
+  # 
+  # 
+  class VListBox < VScrolledWindow
+  
+    # @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] 
+    #   @return [void]
+    def set_margins(*args) end
+    alias_method :margins=, :set_margins
+    
+    # @overload initialize()
+    #   Default constructor, you must call {Wx::VListBox#create} later.
+    #   @return [VListBox]
+    # @overload initialize(parent, id=Wx::ID_ANY, pos=Wx::DEFAULT_POSITION, size=Wx::DEFAULT_SIZE, style=0, name=Wx::V_LIST_BOX_NAME_STR)
+    #   Normal constructor which calls {Wx::VListBox#create} internally.
+    #   @param parent [Wx::Window] 
+    #   @param id [Integer] 
+    #   @param pos [Array(Integer, Integer), Wx::Point] 
+    #   @param size [Array(Integer, Integer), Wx::Size] 
+    #   @param style [Integer] 
+    #   @param name [String] 
+    #   @return [VListBox]
+    def initialize(*args) end
+    
+    # Deletes all items from the control.
+    # @return [void]
+    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.
+    # @param parent [Wx::Window] 
+    # @param id [Integer] 
+    # @param pos [Array(Integer, Integer), Wx::Point] 
+    # @param size [Array(Integer, Integer), Wx::Size] 
+    # @param style [Integer] 
+    # @param name [String] 
+    # @return [true,false]
+    def create(parent, id=Wx::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
+    # @see  Wx::VListBox#select 
+    # @return [true,false]
+    def deselect_all; end
+    
+    # Returns the index of the first selected item in the listbox or {Wx::NOT_FOUND} if no items are currently selected.
+    # cookie is an opaque parameter which should be passed to the subsequent calls to {Wx::VListBox#get_next_selected}. It is needed in order to allow parallel iterations over the selected items.
+    # Here is a typical example of using these functions:
+    # 
+    #   unsigned long cookie;
+    #   int item = hlbox->GetFirstSelected(cookie);
+    #   while ( item != wxNOT_FOUND )
+    #   {
+    #       // ... process item ...
+    #       item = hlbox->GetNextSelected(cookie);
+    #   }
+    # 
+    # This method is only valid for multi selection listboxes.
+    # @param cookie [unsigned long] 
+    # @return [Integer]
+    def get_first_selected(cookie) end
+    alias_method :first_selected, :get_first_selected
+    
+    # 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]
+    def get_margins; end
+    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]
+    def get_item_rect(item) end
+    alias_method :item_rect, :get_item_rect
+    
+    # Returns the index of the next selected item or {Wx::NOT_FOUND} if there are no more.
+    # This method is only valid for multi selection listboxes.
+    # @see Wx::VListBox#get_first_selected 
+    # @param cookie [unsigned long] 
+    # @return [Integer]
+    def get_next_selected(cookie) end
+    alias_method :next_selected, :get_next_selected
+    
+    # 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
+    # @see  Wx::VListBox#get_next_selected 
+    # @return [Integer]
+    def get_selected_count; end
+    alias_method :selected_count, :get_selected_count
+    
+    # Get the currently selected item or {Wx::NOT_FOUND} if there is no selection.
+    # @return [Integer]
+    def get_selection; end
+    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 
+    # @return [Wx::Colour,String,Symbol]
+    def get_selection_background; end
+    alias_method :selection_background, :get_selection_background
+    
+    # Returns true if the listbox was created with {Wx::LB_MULTIPLE} style and so supports multiple selection or false if it is a single selection listbox.
+    # @return [true,false]
+    def has_multiple_selection; end
+    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 [true,false]
+    def is_current(item) end
+    alias_method :current?, :is_current
+    
+    # Returns true if this item is selected, false otherwise.
+    # @param item [Integer] 
+    # @return [true,false]
+    def is_selected(item) end
+    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.
+    # @param item [Integer] 
+    # @param select [true,false] 
+    # @return [true,false]
+    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.
+    # @see Wx::VListBox#deselect_all
+    # @see  Wx::VListBox#select 
+    # @return [true,false]
+    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.
+    # @see Wx::VListBox#select_all
+    # @see  Wx::VListBox#select 
+    # @param from [Integer] 
+    # @param to [Integer] 
+    # @return [true,false]
+    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]
+    def set_item_count(count) end
+    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] 
+    # @return [void]
+    def set_selection(selection) end
+    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}.
+    # Using a non-default background colour may result in control having an appearance different from the similar native controls and should be avoided in general.
+    # @see Wx::VListBox#get_selection_background 
+    # @param col [Wx::Colour,String,Symbol] 
+    # @return [void]
+    def set_selection_background(col) end
+    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] 
+    # @return [void]
+    def toggle(item) end
+    
+  end # VListBox
+  
+
+end

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

@@ -0,0 +1,224 @@
+# :stopdoc:
+# This file is automatically generated by the WXRuby3 documentation 
+# generator. Do not alter this file.
+# :startdoc:
+
+
+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.
+  # 
+  # == wxWidgets 2.8 Compatibility Functions
+  # 
+  # The following functions provide backwards compatibility for applications originally built using {Wx::VScrolledWindow} in 2.6 or 2.8. Originally, {Wx::VScrolledWindow} referred to scrolling "lines". We now use "units" in {Wx::VarScrollHelperBase} to avoid implying any orientation (since the functions are used for both horizontal and vertical scrolling in derived classes). And in the new {Wx::VScrolledWindow} and {Wx::HScrolledWindow} classes, we refer to them as "rows" and "columns", respectively. This is to help clear some confusion in not only those classes, but also in {Wx::HVScrolledWindow} where functions are inherited from both.
+  # You are encouraged to update any existing code using these function to use the new replacements mentioned below, and avoid using these functions for any new code as they are deprecated.
+  # 
+  # <code>size_t GetFirstVisibleLine() const</code> 
+  # Deprecated for {Wx::VScrolledWindow#get_visible_rows_begin}.  
+  # 
+  # <code>size_t GetLastVisibleLine() const</code> 
+  # Deprecated for {Wx::VScrolledWindow#get_visible_rows_end}. This function originally had a slight design flaw in that it was possible to return <code>(size_t)-1</code> (ie: a large positive number) if the scroll position was 0 and the first line wasn't completely visible.  
+  # 
+  # <code>size_t GetLineCount() const</code> 
+  # Deprecated for {Wx::VScrolledWindow#get_row_count}.  
+  # 
+  # <code>int HitTest(wxCoord x, wxCoord y) const 
+  # 
+  #  int HitTest(const Wx::Point& pt) const</code> 
+  # Deprecated for {Wx::VScrolledWindow#virtual_hit_test}.  
+  # 
+  # <code>virtual wxCoord OnGetLineHeight(size_t line) const</code> 
+  # Deprecated for {Wx::VScrolledWindow#on_get_row_height}.  
+  # 
+  # <code>virtual void OnGetLinesHint(size_t lineMin, size_t lineMax) const</code> 
+  # Deprecated for {Wx::VScrolledWindow#on_get_rows_height_hint}.  
+  # 
+  # <code>virtual void RefreshLine(size_t line)</code> 
+  # Deprecated for {Wx::VScrolledWindow#refresh_row}.  
+  # 
+  # <code>virtual void RefreshLines(size_t from, size_t to)</code> 
+  # Deprecated for {Wx::VScrolledWindow#refresh_rows}.  
+  # 
+  # <code>virtual bool ScrollLines(int lines)</code> 
+  # Deprecated for {Wx::VScrolledWindow#scroll_rows}.  
+  # 
+  # <code>virtual bool ScrollPages(int pages)</code> 
+  # Deprecated for {Wx::VScrolledWindow#scroll_row_pages}.  
+  # 
+  # <code>bool ScrollToLine(size_t line)</code> 
+  # Deprecated for {Wx::VScrolledWindow#scroll_to_row}.  
+  # 
+  # <code>void SetLineCount(size_t count)</code> 
+  # Deprecated for {Wx::VScrolledWindow#set_row_count}.  
+  # 
+  # === 
+  # 
+  # Category:  Miscellaneous Windows
+  # @see Wx::HScrolledWindow
+  # @see  Wx::HVScrolledWindow 
+  # 
+  # 
+  class VScrolledWindow < Panel
+  
+    # @overload initialize()
+    #   Default constructor, you must call {Wx::VScrolledWindow#create} later.
+    #   @return [VScrolledWindow]
+    # @overload initialize(parent, id=Wx::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.
+    #   {Wx::VSCROLL} is always automatically added to the style, there is no need to specify it explicitly.
+    #   @param parent [Wx::Window]  The parent window, must not be NULL.
+    #   @param id [Integer]  The identifier of this window, {Wx::StandardID::ID_ANY} by default.
+    #   @param pos [Array(Integer, Integer), Wx::Point]  The initial window position.
+    #   @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]
+    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] 
+    # @param pos [Array(Integer, Integer), Wx::Point] 
+    # @param size [Array(Integer, Integer), Wx::Size] 
+    # @param style [Integer] 
+    # @param name [String] 
+    # @return [true,false]
+    def create(parent, id=Wx::ID_ANY, pos=Wx::DEFAULT_POSITION, size=Wx::DEFAULT_SIZE, style=0, name=Wx::PANEL_NAME_STR) end
+    
+    # Returns the number of rows the target window contains.
+    # 
+    # @see Wx::VScrolledWindow#set_row_count 
+    # @return [Integer]
+    def get_row_count; end
+    alias_method :row_count, :get_row_count
+    
+    # Returns the index of the first visible row based on the scroll position.
+    # @return [Integer]
+    def get_visible_rows_begin; end
+    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
+    alias_method :visible_rows_end, :get_visible_rows_end
+    
+    # Returns true if the given row is currently visible (even if only partially visible) or false otherwise.
+    # @param row [Integer] 
+    # @return [true,false]
+    def is_row_visible(row) end
+    alias_method :row_visible?, :is_row_visible
+    
+    # Triggers a refresh for just the given row's area of the window if it's visible.
+    # @param row [Integer] 
+    # @return [void]
+    def refresh_row(row) end
+    
+    # Triggers a refresh for the area between the specified range of rows given (inclusively).
+    # @param from [Integer] 
+    # @param to [Integer] 
+    # @return [void]
+    def refresh_rows(from, to) end
+    
+    # Scroll by the specified number of pages which may be positive (to scroll down) or negative (to scroll up).
+    # @param pages [Integer] 
+    # @return [true,false]
+    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 [true,false]
+    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] 
+    # @return [true,false]
+    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] 
+    # @return [void]
+    def set_row_count(rowCount) end
+    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] 
+    # @return [Integer]
+    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] 
+    # @return [Integer]
+    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 [true,false] 
+    # @return [void]
+    def enable_physical_scrolling(scrolling=true) end
+    
+    # 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
+    alias_method :target_window, :get_target_window
+    
+    # Returns the index of the first visible unit based on the scroll position.
+    # @return [Integer]
+    def get_visible_begin; end
+    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
+    alias_method :visible_end, :get_visible_end
+    
+    # Returns true if the given scroll unit is currently visible (even if only partially visible) or false otherwise.
+    # @param unit [Integer] 
+    # @return [true,false]
+    def is_visible(unit) end
+    alias_method :visible?, :is_visible
+    
+    # Recalculate all parameters and repaint all units.
+    # @return [void]
+    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] 
+    # @return [void]
+    def set_target_window(target) end
+    alias_method :target_window=, :set_target_window
+    
+    # Update the thumb size shown by the scrollbar.
+    # @return [void]
+    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]
+    def virtual_hit_test(coord) end
+    
+    
+    protected
+    
+  end # VScrolledWindow
+  
+
+end

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

@@ -0,0 +1,73 @@
+# :stopdoc:
+# This file is automatically generated by the WXRuby3 documentation 
+# generator. Do not alter this file.
+# :startdoc:
+
+
+module Wx
+
+  # An empty, "null" {Wx::Validator} instance.
+  # 
+  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.- 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}.
+  # For more information, please see wxValidator Overview.
+  # === 
+  # 
+  # Category:  {Wx::Validators}
+  # Predefined objects/pointers: {Wx::DEFAULT_VALIDATOR}
+  # @see wxValidator Overview
+  # @see  Wx::TextValidator
+  # @see  Wx::GenericValidator
+  # @see  Wx::IntegerValidator
+  # @see  Wx::FloatingPointValidator 
+  # 
+  # 
+  class Validator < EvtHandler
+  
+    # Constructor.
+    # @return [Validator]
+    def initialize; 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. 
+    # 
+    #   new wxTextCtrl(this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0,
+    #                  wxTextValidator(wxFILTER_ALPHA, &g_data.m_string));
+    #  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 [true,false]
+    def validate(parent) end
+    
+    # This functions switches on or turns off the error sound produced by the validators if an invalid key is pressed.
+    # @param suppress [true,false]  If true, error sound is not played when a validator detects an error. If false, error sound is enabled.
+    # @return [void]
+    def self.suppress_bell_on_error(suppress=true) end
+    
+    # Returns if the error sound is currently disabled.
+    # @return [true,false]
+    def self.is_silent; end
+    
+  end # Validator
+  
+
+end