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

data/lib/wx/doc/gen/grid/grid_ctrl.rb

@@ -13,6 +13,7 @@ module Wx::GRID
   # 
   # 
   # 
+  # @wxrb_require USE_GRID
   class GridCellFloatFormat < Wx::Enum
   
     # Decimal floating point (f).
@@ -41,6 +42,7 @@ module Wx::GRID
   # 
   # 
   # 
+  # @wxrb_require USE_GRID
   class GridTableRequest < Wx::Enum
   
     # New rows have been inserted into the table.
@@ -73,6 +75,7 @@ module Wx::GRID
   # 
   # 
   # 
+  # @wxrb_require USE_GRID
   class GridRenderStyle < Wx::Enum
   
     # Draw grid row header labels.
@@ -202,6 +205,7 @@ module Wx::GRID
   EVT_GRID_TABBING = 10075
   
   # {Wx::GRID::Grid} and its related classes are used for displaying and editing tabular data.
+  # 
   # They provide a rich set of features for display, editing, and interacting with a variety of data sources. For simple applications, and to help you get started, {Wx::GRID::Grid} is the only class you need to refer to directly. It will set up default instances of the other classes and manage them for you. For more complex applications you can derive your own classes for custom grid views, grid data tables, cell editors and renderers. The wxGrid Overview has examples of simple and more complex applications, explains the relationship between the various grid classes and has a summary of the keyboard shortcuts and mouse functions provided by {Wx::GRID::Grid}.
   # A {Wx::GRID::GridTableBase} class holds the actual data to be displayed by a {Wx::GRID::Grid} class. One or more {Wx::GRID::Grid} classes may act as a view for one table class. The default table class is called {Wx::GRID::GridStringTable} and holds an array of strings. An instance of such a class is created by {Wx::GRID::Grid#create_grid}.
   # {Wx::GRID::GridCellRenderer} is the abstract base class for rendering contents in a cell. The following renderers are predefined:
@@ -224,19 +228,20 @@ module Wx::GRID
   # - {Wx::GRID::GridCellDateEditor}
   # 
   # Please see {Wx::GRID::GridEvent}, {Wx::GRID::GridSizeEvent}, {Wx::GRID::GridRangeSelectEvent}, and {Wx::GRID::GridEditorCreatedEvent} for the documentation of all event types you can use with {Wx::GRID::Grid}.
-  # === 
   # 
   # Category:  Grid Related Classes
   # @see wxGrid Overview
   # @see  Wx::GridUpdateLocker 
   # 
   # 
+  # @wxrb_require USE_GRID
   class Grid < ScrolledCanvas
   
     # Different selection modes supported by the grid.
     # 
     # 
     # 
+    # @wxrb_require USE_GRID
     class GridSelectionModes < Wx::Enum
     
       # The default selection mode allowing selection of the individual cells as well as of the entire rows and columns.
@@ -265,6 +270,7 @@ module Wx::GRID
     # 
     # 
     # 
+    # @wxrb_require USE_GRID
     class CellSpan < Wx::Enum
     
       # This cell is inside a span covered by another cell.
@@ -288,6 +294,7 @@ module Wx::GRID
     # @see  Wx::GRID::EVT_GRID_TABBING 
     # 
     # 
+    # @wxrb_require USE_GRID
     class TabBehaviour < Wx::Enum
     
       # Do nothing, this is default.
@@ -306,10 +313,12 @@ module Wx::GRID
     
     # @overload initialize()
     #   Default constructor.
+    #   
     #   You must call {Wx::GRID::Grid#create} to really create the grid window and also call {Wx::GRID::Grid#create_grid} or {Wx::GRID::Grid#set_table} or {Wx::GRID::Grid#assign_table} to initialize its contents.
     #   @return [Wx::GRID::Grid]
     # @overload initialize(parent, id, pos=Wx::DEFAULT_POSITION, size=Wx::DEFAULT_SIZE, style=Wx::WANTS_CHARS, name=Wx::GRID_NAME_STR)
     #   Constructor creating the grid window.
+    #   
     #   You must call either {Wx::GRID::Grid#create_grid} or {Wx::GRID::Grid#set_table} or {Wx::GRID::Grid#assign_table} to initialize the grid contents before using it.
     #   @param parent [Wx::Window] 
     #   @param id [Integer] 
@@ -321,6 +330,7 @@ module Wx::GRID
     def initialize(*args) end
     
     # Creates the grid window for an object initialized using the default constructor.
+    # 
     # You must call either {Wx::GRID::Grid#create_grid} or {Wx::GRID::Grid#set_table} or {Wx::GRID::Grid#assign_table} to initialize the grid contents before using it.
     # @param parent [Wx::Window] 
     # @param id [Integer] 
@@ -332,19 +342,21 @@ module Wx::GRID
     def create(parent, id, pos=Wx::DEFAULT_POSITION, size=Wx::DEFAULT_SIZE, style=Wx::WANTS_CHARS, name=Wx::GRID_NAME_STR) end
     
     # Creates a grid with the specified initial number of rows and columns.
+    # 
     # Call this directly after the grid constructor. When you use this function {Wx::GRID::Grid} will create and manage a simple table of string values for you. All of the grid data will be stored in memory.
     # For applications with more complex data types or relationships, or for dealing with very large datasets, you should derive your own grid table class and pass a table object to the grid with {Wx::GRID::Grid#set_table} or {Wx::GRID::Grid#assign_table}.
     # @param numRows [Integer] 
     # @param numCols [Integer] 
-    # @param selmode [Wx::wxGrid::GridSelectionModes] 
+    # @param selmode [Wx::Grid::GridSelectionModes] 
     # @return [Boolean]
     def create_grid(numRows, numCols, selmode=Wx::GRID::Grid::GridSelectionModes::GridSelectCells) end
     
     # Assigns a pointer to a custom grid table to be used by the grid.
+    # 
     # This function is identical to {Wx::GRID::Grid#set_table} with takeOwnership parameter set to true, i.e. it simply always takes the ownership of the passed in pointer. This makes it simpler to use than {Wx::GRID::Grid#set_table} in the common case when the table should be owned by the grid object.
     # Note that this function should be called at most once and can't be used to change the table used by the grid later on or reset it: if such extra flexibility is needed, use {Wx::GRID::Grid#set_table} directly.
     # @param table [Wx::GRID::GridTableBase]  The heap-allocated pointer to the table.
-    # @param selmode [Wx::wxGrid::GridSelectionModes]  Selection mode to use.
+    # @param selmode [Wx::Grid::GridSelectionModes]  Selection mode to use.
     # @return [void]
     def assign_table(table, selmode=Wx::GRID::Grid::GridSelectionModes::GridSelectCells) end
     
@@ -359,6 +371,7 @@ module Wx::GRID
     def enable_grid_lines(enable=true) end
     
     # Returns the pen used for vertical grid lines.
+    # 
     # This virtual function may be overridden in derived classes in order to change the appearance of individual grid lines for the given column col.
     # See {Wx::GRID::Grid#get_row_grid_line_pen} for an example.
     # @param col [Integer] 
@@ -367,6 +380,7 @@ module Wx::GRID
     alias_method :col_grid_line_pen, :get_col_grid_line_pen
     
     # Returns the pen used for grid lines.
+    # 
     # This virtual function may be overridden in derived classes in order to change the appearance of grid lines. Note that currently the pen width must be 1.
     # @see Wx::GRID::Grid#get_col_grid_line_pen
     # @see  Wx::GRID::Grid#get_row_grid_line_pen 
@@ -376,12 +390,14 @@ module Wx::GRID
     
     # Returns the colour used for grid lines.
     # 
+    # 
     # @see Wx::GRID::Grid#get_default_grid_line_pen 
     # @return [Wx::Colour]
     def get_grid_line_colour; end
     alias_method :grid_line_colour, :get_grid_line_colour
     
     # Returns the pen used for horizontal grid lines.
+    # 
     # This virtual function may be overridden in derived classes in order to change the appearance of individual grid line for the given row.
     # Example: 
     # ```ruby
@@ -417,6 +433,7 @@ module Wx::GRID
     alias_method :grid_line_colour=, :set_grid_line_colour
     
     # Sets the arguments to the current column label alignment values.
+    # 
     # Horizontal alignment will be one of {Wx::Alignment::ALIGN_LEFT}, {Wx::Alignment::ALIGN_CENTRE} or {Wx::Alignment::ALIGN_RIGHT}.
     # Vertical alignment will be one of {Wx::Alignment::ALIGN_TOP}, {Wx::Alignment::ALIGN_CENTRE} or {Wx::Alignment::ALIGN_BOTTOM}.
     # @return [Array(Integer,Integer)]
@@ -429,6 +446,7 @@ module Wx::GRID
     alias_method :col_label_text_orientation, :get_col_label_text_orientation
     
     # Returns the specified column label.
+    # 
     # The default grid table class provides column labels of the form A,B...Z,AA,AB...ZZ,AAA... If you are using a custom grid table you can override {Wx::GRID::GridTableBase#get_col_label_value} to provide your own labels.
     # @param col [Integer] 
     # @return [String]
@@ -436,6 +454,7 @@ module Wx::GRID
     alias_method :col_label_value, :get_col_label_value
     
     # Sets the arguments to the current corner label alignment values.
+    # 
     # Horizontal alignment will be one of {Wx::Alignment::ALIGN_LEFT}, {Wx::Alignment::ALIGN_CENTRE} or {Wx::Alignment::ALIGN_RIGHT}.
     # Vertical alignment will be one of {Wx::Alignment::ALIGN_TOP}, {Wx::Alignment::ALIGN_CENTRE} or {Wx::Alignment::ALIGN_BOTTOM}.
     # @return [Array(Integer,Integer)]
@@ -468,6 +487,7 @@ module Wx::GRID
     alias_method :label_text_colour, :get_label_text_colour
     
     # Returns the alignment used for row labels.
+    # 
     # Horizontal alignment will be one of {Wx::Alignment::ALIGN_LEFT}, {Wx::Alignment::ALIGN_CENTRE} or {Wx::Alignment::ALIGN_RIGHT}.
     # Vertical alignment will be one of {Wx::Alignment::ALIGN_TOP}, {Wx::Alignment::ALIGN_CENTRE} or {Wx::Alignment::ALIGN_BOTTOM}.
     # @return [Array(Integer,Integer)]
@@ -475,6 +495,7 @@ module Wx::GRID
     alias_method :row_label_alignment, :get_row_label_alignment
     
     # Returns the specified row label.
+    # 
     # The default grid table class provides numeric row labels. If you are using a custom grid table you can override {Wx::GRID::GridTableBase#get_row_label_value} to provide your own labels.
     # @param row [Integer] 
     # @return [String]
@@ -482,6 +503,7 @@ module Wx::GRID
     alias_method :row_label_value, :get_row_label_value
     
     # Hides the column labels by calling {Wx::GRID::Grid#set_col_label_size} with a size of 0.
+    # 
     # The labels can be shown again by calling {Wx::GRID::Grid#set_col_label_size} with a height greater than 0.
     # Note that when the column labels are hidden, the grid won't have any visible border on the top side, which may result in a less than ideal appearance. Because of this, you may want to create the grid window with a border style, such as {Wx::Border::BORDER_SIMPLE}, when you don't plan to show the column labels for it.
     # @see Wx::GRID::Grid#hide_row_labels 
@@ -489,12 +511,14 @@ module Wx::GRID
     def hide_col_labels; end
     
     # Hides the row labels by calling {Wx::GRID::Grid#set_row_label_size} with a size of 0.
+    # 
     # The labels can be shown again by calling {Wx::GRID::Grid#set_row_label_size} with a width greater than 0.
     # See {Wx::GRID::Grid#hide_col_labels} for a note explaining why you may want to use a border with a grid without the row labels.
     # @return [void]
     def hide_row_labels; end
     
     # Sets the horizontal and vertical alignment of column label text.
+    # 
     # Horizontal alignment should be one of {Wx::Alignment::ALIGN_LEFT}, {Wx::Alignment::ALIGN_CENTRE} or {Wx::Alignment::ALIGN_RIGHT}. Vertical alignment should be one of {Wx::Alignment::ALIGN_TOP}, {Wx::Alignment::ALIGN_CENTRE} or {Wx::Alignment::ALIGN_BOTTOM}.
     # @param horiz [Integer] 
     # @param vert [Integer] 
@@ -508,6 +532,7 @@ module Wx::GRID
     alias_method :col_label_text_orientation=, :set_col_label_text_orientation
     
     # Set the value for the given column label.
+    # 
     # If you are using a custom grid table you must override {Wx::GRID::GridTableBase#set_col_label_value} for this to have any effect.
     # @param col [Integer] 
     # @param value [String] 
@@ -515,6 +540,7 @@ module Wx::GRID
     def set_col_label_value(col, value) end
     
     # Sets the horizontal and vertical alignment of the (top-left) corner label text.
+    # 
     # Horizontal alignment should be one of {Wx::Alignment::ALIGN_LEFT}, {Wx::Alignment::ALIGN_CENTRE} or {Wx::Alignment::ALIGN_RIGHT}. Vertical alignment should be one of {Wx::Alignment::ALIGN_TOP}, {Wx::Alignment::ALIGN_CENTRE} or {Wx::Alignment::ALIGN_BOTTOM}.
     # @param horiz [Integer] 
     # @param vert [Integer] 
@@ -528,6 +554,7 @@ module Wx::GRID
     alias_method :corner_label_text_orientation=, :set_corner_label_text_orientation
     
     # Set the value for the (top-left) corner label.
+    # 
     # If you are using a custom grid table you must override {Wx::GRID::GridTableBase#set_corner_label_value} for this to have any effect.
     # @param arg [String] 
     # @return [void]
@@ -553,6 +580,7 @@ module Wx::GRID
     alias_method :label_text_colour=, :set_label_text_colour
     
     # Sets the horizontal and vertical alignment of row label text.
+    # 
     # Horizontal alignment should be one of {Wx::Alignment::ALIGN_LEFT}, {Wx::Alignment::ALIGN_CENTRE} or {Wx::Alignment::ALIGN_RIGHT}. Vertical alignment should be one of {Wx::Alignment::ALIGN_TOP}, {Wx::Alignment::ALIGN_CENTRE} or {Wx::Alignment::ALIGN_BOTTOM}.
     # @param horiz [Integer] 
     # @param vert [Integer] 
@@ -560,6 +588,7 @@ module Wx::GRID
     def set_row_label_alignment(horiz, vert) end
     
     # Sets the value for the given row label.
+    # 
     # If you are using a derived grid table you must override {Wx::GRID::GridTableBase#set_row_label_value} for this to have any effect.
     # @param row [Integer] 
     # @param value [String] 
@@ -567,6 +596,7 @@ module Wx::GRID
     def set_row_label_value(row, value) end
     
     # Call this in order to make the column labels use a native look by using Wx::RendererNative#draw_header_button internally.
+    # 
     # There is no equivalent method for drawing row columns as there is not native look for that. This option is useful when using {Wx::GRID::Grid} for displaying tables and not as a spread-sheet.
     # @see Wx::GRID::Grid#use_native_col_header 
     # @param native [Boolean] 
@@ -575,6 +605,7 @@ module Wx::GRID
     alias_method :use_native_col_labels=, :set_use_native_col_labels
     
     # Enable the use of native header window for column labels.
+    # 
     # If this function is called with true argument, a {Wx::HeaderCtrl} is used instead to display the column labels instead of drawing them in {Wx::GRID::Grid} code itself. This has the advantage of making the grid look and feel perfectly the same as native applications (using {Wx::GRID::Grid#set_use_native_col_labels} the grid can be made to look more natively but it still doesn't feel natively, notably the column resizing and dragging still works slightly differently as it is implemented in wxWidgets itself) but results in different behaviour for column and row headers, for which there is no equivalent function, and, most importantly, is unsuitable for grids with huge numbers of columns as {Wx::HeaderCtrl} doesn't support virtual mode. Because of this, by default the grid does not use the native header control but you should call this function to enable it if you are using the grid to display tabular data and don't have thousands of columns in it.
     # Another difference between the default behaviour and the native header behaviour is that the latter provides the user with a context menu (which appears on right clicking the header) allowing to rearrange the grid columns if {Wx::GRID::Grid#can_drag_col_move} returns true. If you want to prevent this from happening for some reason, you need to define a handler for {Wx::GRID::EVT_GRID_LABEL_RIGHT_CLICK} event which simply does nothing (in particular doesn't skip the event) as this will prevent the default right click handling from working.
     # Also note that currently {Wx::GRID::EVT_GRID_LABEL_RIGHT_DCLICK} event is not generated for the column labels if the native columns header is used (but this limitation could possibly be lifted in the future).
@@ -584,6 +615,7 @@ module Wx::GRID
     def use_native_col_header(native=true) end
     
     # Sets the arguments to the horizontal and vertical text alignment values for the grid cell at the specified location.
+    # 
     # Horizontal alignment will be one of {Wx::Alignment::ALIGN_LEFT}, {Wx::Alignment::ALIGN_CENTRE} or {Wx::Alignment::ALIGN_RIGHT}.
     # Vertical alignment will be one of {Wx::Alignment::ALIGN_TOP}, {Wx::Alignment::ALIGN_CENTRE} or {Wx::Alignment::ALIGN_BOTTOM}.
     # @param row [Integer] 
@@ -614,6 +646,7 @@ module Wx::GRID
     alias_method :cell_text_colour, :get_cell_text_colour
     
     # Returns the default cell alignment.
+    # 
     # Horizontal alignment will be one of {Wx::Alignment::ALIGN_LEFT}, {Wx::Alignment::ALIGN_CENTRE} or {Wx::Alignment::ALIGN_RIGHT}.
     # Vertical alignment will be one of {Wx::Alignment::ALIGN_TOP}, {Wx::Alignment::ALIGN_CENTRE} or {Wx::Alignment::ALIGN_BOTTOM}.
     # @see Wx::GRID::Grid#set_default_cell_alignment 
@@ -637,6 +670,7 @@ module Wx::GRID
     alias_method :default_cell_text_colour, :get_default_cell_text_colour
     
     # Sets the horizontal and vertical alignment for grid cell text at the specified location.
+    # 
     # Horizontal alignment should be one of {Wx::Alignment::ALIGN_LEFT}, {Wx::Alignment::ALIGN_CENTRE} or {Wx::Alignment::ALIGN_RIGHT}.
     # Vertical alignment should be one of {Wx::Alignment::ALIGN_TOP}, {Wx::Alignment::ALIGN_CENTRE} or {Wx::Alignment::ALIGN_BOTTOM}.
     # @param row [Integer] 
@@ -666,9 +700,9 @@ module Wx::GRID
     # @param colour [Wx::Colour,String,Symbol] 
     # @return [void]
     def set_cell_text_colour(row, col, colour) end
-    alias_method :cell_text_colour=, :set_cell_text_colour
     
     # Sets the default horizontal and vertical alignment for grid cell text.
+    # 
     # Horizontal alignment should be one of {Wx::Alignment::ALIGN_LEFT}, {Wx::Alignment::ALIGN_CENTRE} or {Wx::Alignment::ALIGN_RIGHT}. Vertical alignment should be one of {Wx::Alignment::ALIGN_TOP}, {Wx::Alignment::ALIGN_CENTRE} or {Wx::Alignment::ALIGN_BOTTOM}.
     # @param horiz [Integer] 
     # @param vert [Integer] 
@@ -694,17 +728,20 @@ module Wx::GRID
     alias_method :default_cell_text_colour=, :set_default_cell_text_colour
     
     # Returns true if the in-place edit control for the current grid cell can be used and false otherwise.
+    # 
     # This function always returns false for the read-only cells.
     # @return [Boolean]
     def can_enable_cell_control; end
     alias_method :can_enable_cell_control?, :can_enable_cell_control
     
     # Disables in-place editing of grid cells.
+    # 
     # Equivalent to calling EnableCellEditControl(false).
     # @return [void]
     def disable_cell_edit_control; end
     
     # Enables or disables in-place editing of grid cell data.
+    # 
     # Enabling in-place editing generates {Wx::GRID::EVT_GRID_EDITOR_SHOWN} and, if it isn't vetoed by the application, shows the in-place editor which allows the user to change the cell value.
     # Disabling in-place editing does nothing if the in-place editor isn't currently shown, otherwise the {Wx::GRID::EVT_GRID_EDITOR_HIDDEN} event is generated but, unlike the "shown" event, it can't be vetoed and the in-place editor is dismissed unconditionally.
     # Note that it is an error to call this function if the current cell is read-only, use {Wx::GRID::Grid#can_enable_cell_control} to check for this precondition.
@@ -713,6 +750,7 @@ module Wx::GRID
     def enable_cell_edit_control(enable=true) end
     
     # Makes the grid globally editable or read-only.
+    # 
     # If the edit argument is false this function sets the whole grid as read-only. If the argument is true the grid is set to the default state where cells may be editable. In the default state you can set single grid cells and whole rows and columns to be editable or read-only via {Wx::GRID::GridCellAttr#set_read_only}. For single cells you can also use the shortcut function {Wx::GRID::Grid#set_read_only}.
     # For more information about controlling grid cell attributes see the {Wx::GRID::GridCellAttr} class and the wxGrid Overview.
     # @param edit [Boolean] 
@@ -720,6 +758,7 @@ module Wx::GRID
     def enable_editing(edit) end
     
     # Returns a pointer to the editor for the cell at the specified location.
+    # 
     # See {Wx::GRID::GridCellEditor} and the wxGrid Overview for more information about cell editors and renderers.
     # The caller must call DecRef() on the returned pointer.
     # @param row [Integer] 
@@ -729,6 +768,7 @@ module Wx::GRID
     alias_method :cell_editor, :get_cell_editor
     
     # Returns a pointer to the renderer for the grid cell at the specified location.
+    # 
     # See {Wx::GRID::GridCellRenderer} and the wxGrid Overview for more information about cell editors and renderers.
     # The caller must call DecRef() on the returned pointer.
     # @param row [Integer] 
@@ -738,6 +778,7 @@ module Wx::GRID
     alias_method :cell_renderer, :get_cell_renderer
     
     # Returns the string contained in the cell at the specified location.
+    # 
     # For simple applications where a grid object automatically uses a default grid table of string values you use this function together with {Wx::GRID::Grid#set_cell_value} to access cell values. For more complex applications where you have derived your own grid table class that contains various data types (e.g. numeric, boolean or user-defined custom types) then you only use this function for those cells that contain string values.
     # See {Wx::GRID::GridTableBase#can_get_value_as} and the wxGrid Overview for more information.
     # @param row [Integer] 
@@ -747,12 +788,14 @@ module Wx::GRID
     alias_method :cell_value, :get_cell_value
     
     # Returns a pointer to the current default grid cell editor.
+    # 
     # See {Wx::GRID::GridCellEditor} and the wxGrid Overview for more information about cell editors and renderers.
     # @return [Wx::GRID::GridCellEditor]
     def get_default_editor; end
     alias_method :default_editor, :get_default_editor
     
     # Returns the default editor for the specified cell.
+    # 
     # The base class version returns the editor appropriate for the current cell type but this method may be overridden in the derived classes to use custom editors for some cells by default.
     # Notice that the same may be achieved in a usually simpler way by associating a custom editor with the given cell or cells.
     # The caller must call DecRef() on the returned pointer.
@@ -763,6 +806,7 @@ module Wx::GRID
     alias_method :default_editor_for_cell, :get_default_editor_for_cell
     
     # Returns the default editor for the cells containing values of the given type.
+    # 
     # The base class version returns the editor which was associated with the specified typeName when it was registered {Wx::GRID::Grid#register_data_type} but this function may be overridden to return something different. This allows overriding an editor used for one of the standard types.
     # The caller must call DecRef() on the returned pointer.
     # @param typeName [String] 
@@ -771,6 +815,7 @@ module Wx::GRID
     alias_method :default_editor_for_type, :get_default_editor_for_type
     
     # Returns a pointer to the current default grid cell renderer.
+    # 
     # See {Wx::GRID::GridCellRenderer} and the wxGrid Overview for more information about cell editors and renderers.
     # The caller must call DecRef() on the returned pointer.
     # @return [Wx::GRID::GridCellRenderer]
@@ -778,6 +823,7 @@ module Wx::GRID
     alias_method :default_renderer, :get_default_renderer
     
     # Returns the default renderer for the given cell.
+    # 
     # The base class version returns the renderer appropriate for the current cell type but this method may be overridden in the derived classes to use custom renderers for some cells by default.
     # The caller must call DecRef() on the returned pointer.
     # @param row [Integer] 
@@ -788,6 +834,7 @@ module Wx::GRID
     
     # Returns the default renderer for the cell containing values of the given type.
     # 
+    # 
     # @see Wx::GRID::Grid#get_default_editor_for_type 
     # @param typeName [String] 
     # @return [Wx::GRID::GridCellRenderer]
@@ -805,6 +852,7 @@ module Wx::GRID
     
     # Returns true if the in-place edit control is currently shown.
     # 
+    # 
     # @see Wx::GRID::Grid#hide_cell_edit_control 
     # @return [Boolean]
     def is_cell_edit_control_shown; end
@@ -812,6 +860,7 @@ module Wx::GRID
     
     # Returns true if the current cell is read-only.
     # 
+    # 
     # @see Wx::GRID::Grid#set_read_only
     # @see  Wx::GRID::Grid#is_read_only 
     # @return [Boolean]
@@ -819,6 +868,7 @@ module Wx::GRID
     alias_method :current_cell_read_only?, :is_current_cell_read_only
     
     # Returns false if the whole grid has been set as read-only or true otherwise.
+    # 
     # See {Wx::GRID::Grid#enable_editing} for more information about controlling the editing status of grid cells.
     # @return [Boolean]
     def is_editable; end
@@ -826,6 +876,7 @@ module Wx::GRID
     
     # Returns true if the cell at the specified location can't be edited.
     # 
+    # 
     # @see Wx::GRID::Grid#set_read_only
     # @see  Wx::GRID::Grid#is_current_cell_read_only 
     # @param row [Integer] 
@@ -835,6 +886,7 @@ module Wx::GRID
     alias_method :read_only?, :is_read_only
     
     # Register a new data type.
+    # 
     # The data types allow to naturally associate specific renderers and editors to the cells containing values of the given type. For example, the grid automatically registers a data type with the name {Wx::GRID::GRID_VALUE_STRING} which uses {Wx::GRID::GridCellStringRenderer} and {Wx::GRID::GridCellTextEditor} as its renderer and editor respectively  this is the data type used by all the cells of the default {Wx::GRID::GridStringTable}, so this renderer and editor are used by default for all grid cells.
     # However if a custom table returns {Wx::GRID::GRID_VALUE_BOOL} from its {Wx::GRID::GridTableBase#get_type_name} method, then {Wx::GRID::GridCellBoolRenderer} and {Wx::GRID::GridCellBoolEditor} are used for it because the grid also registers a boolean data type with this name.
     # And as this mechanism is completely generic, you may register your own data types using your own custom renderers and editors. Just remember that the table must identify a cell as being of the given type for them to be used for this cell.
@@ -845,11 +897,13 @@ module Wx::GRID
     def register_data_type(typeName, renderer, editor) end
     
     # Sets the value of the current grid cell to the current in-place edit control value.
+    # 
     # This is called automatically when the grid cursor moves from the current cell to a new cell. It is also a good idea to call this function when closing a grid since any edits to the final cell location will not be saved otherwise.
     # @return [void]
     def save_edit_control_value; end
     
     # Sets the editor for the grid cell at the specified location.
+    # 
     # The grid will take ownership of the pointer.
     # See {Wx::GRID::GridCellEditor} and the wxGrid Overview for more information about cell editors and renderers.
     # @param row [Integer] 
@@ -859,6 +913,7 @@ module Wx::GRID
     def set_cell_editor(row, col, editor) end
     
     # Sets the renderer for the grid cell at the specified location.
+    # 
     # The grid will take ownership of the pointer.
     # See {Wx::GRID::GridCellRenderer} and the wxGrid Overview for more information about cell editors and renderers.
     # @param row [Integer] 
@@ -868,6 +923,7 @@ module Wx::GRID
     def set_cell_renderer(row, col, renderer) end
     
     # Sets the string value for the cell at the specified location.
+    # 
     # For simple applications where a grid object automatically uses a default grid table of string values you use this function together with {Wx::GRID::Grid#get_cell_value} to access cell values. For more complex applications where you have derived your own grid table class that contains various data types (e.g. numeric, boolean or user-defined custom types) then you only use this function for those cells that contain string values.
     # See {Wx::GRID::GridTableBase#can_set_value_as} and the wxGrid Overview for more information.
     # @param row [Integer] 
@@ -878,6 +934,7 @@ module Wx::GRID
     
     # Sets the specified column to display boolean values.
     # 
+    # 
     # @see Wx::GRID::Grid#set_col_format_custom 
     # @param col [Integer] 
     # @return [void]
@@ -885,6 +942,7 @@ module Wx::GRID
     alias_method :col_format_bool=, :set_col_format_bool
     
     # Sets the specified column to display data in a custom format.
+    # 
     # This method provides an alternative to defining a custom grid table which would return typeName from its GetTypeName() method for the cells in this column: while it doesn't really change the type of the cells in this column, it does associate the renderer and editor used for the cells of the specified type with them.
     # See the wxGrid Overview for more information on working with custom data types.
     # @param col [Integer] 
@@ -894,6 +952,7 @@ module Wx::GRID
     
     # Sets the specified column to display floating point values with the given width and precision.
     # 
+    # 
     # @see Wx::GRID::Grid#set_col_format_custom 
     # @param col [Integer] 
     # @param width [Integer] 
@@ -904,6 +963,7 @@ module Wx::GRID
     
     # Sets the specified column to display integer values.
     # 
+    # 
     # @see Wx::GRID::Grid#set_col_format_custom 
     # @param col [Integer] 
     # @return [void]
@@ -911,6 +971,7 @@ module Wx::GRID
     alias_method :col_format_number=, :set_col_format_number
     
     # Sets the specified column to display date values.
+    # 
     # The format argument is used with {Wx::GRID::GridCellDateRenderer} and allows to specify the strftime-like format string to use for displaying the dates in this column.
     # @see Wx::GRID::Grid#set_col_format_custom
     # @param col [Integer] 
@@ -920,6 +981,7 @@ module Wx::GRID
     alias_method :col_format_date=, :set_col_format_date
     
     # Sets the default editor for grid cells.
+    # 
     # The grid will take ownership of the pointer.
     # See {Wx::GRID::GridCellEditor} and the wxGrid Overview for more information about cell editors and renderers.
     # @param editor [Wx::GRID::GridCellEditor] 
@@ -928,6 +990,7 @@ module Wx::GRID
     alias_method :default_editor=, :set_default_editor
     
     # Sets the default renderer for grid cells.
+    # 
     # The grid will take ownership of the pointer.
     # See {Wx::GRID::GridCellRenderer} and the wxGrid Overview for more information about cell editors and renderers.
     # @param renderer [Wx::GRID::GridCellRenderer] 
@@ -937,6 +1000,7 @@ module Wx::GRID
     
     # Makes the cell at the specified location read-only or editable.
     # 
+    # 
     # @see Wx::GRID::Grid#is_read_only 
     # @param row [Integer] 
     # @param col [Integer] 
@@ -945,6 +1009,7 @@ module Wx::GRID
     def set_read_only(row, col, isReadOnly=true) end
     
     # Displays the active in-place cell edit control for the current cell after it was hidden.
+    # 
     # This method should only be called after calling {Wx::GRID::Grid#hide_cell_edit_control}, to start editing the current grid cell use {Wx::GRID::Grid#enable_cell_edit_control} instead.
     # @return [void]
     def show_cell_edit_control; end
@@ -959,6 +1024,7 @@ module Wx::GRID
     def auto_size_col_label_size(col) end
     
     # Automatically sizes the column to fit its contents.
+    # 
     # If setAsMin is true the calculated width will also be set as the minimal width for the column.
     # @param col [Integer] 
     # @param setAsMin [Boolean] 
@@ -966,12 +1032,14 @@ module Wx::GRID
     def auto_size_column(col, setAsMin=true) end
     
     # Automatically sizes all columns to fit their contents.
+    # 
     # If setAsMin is true the calculated widths will also be set as the minimal widths for the columns.
     # @param setAsMin [Boolean] 
     # @return [void]
     def auto_size_columns(setAsMin=true) end
     
     # Automatically sizes the row to fit its contents.
+    # 
     # If setAsMin is true the calculated height will also be set as the minimal height for the row.
     # @param row [Integer] 
     # @param setAsMin [Boolean] 
@@ -984,6 +1052,7 @@ module Wx::GRID
     def auto_size_row_label_size(col) end
     
     # Automatically sizes all rows to fit their contents.
+    # 
     # If setAsMin is true the calculated heights will also be set as the minimal heights for the rows.
     # @param setAsMin [Boolean] 
     # @return [void]
@@ -991,6 +1060,7 @@ module Wx::GRID
     
     # Returns the cell fitting mode.
     # 
+    # 
     # @see Wx::GRID::GridFitMode
     # @param row [Integer] 
     # @param col [Integer] 
@@ -999,6 +1069,7 @@ module Wx::GRID
     alias_method :cell_fit_mode, :get_cell_fit_mode
     
     # Returns true if the cell value can overflow.
+    # 
     # This is identical to calling {Wx::GRID::Grid#get_cell_fit_mode} and using {Wx::GRID::GridFitMode#is_overflow} on the returned value.
     # Prefer using {Wx::GRID::Grid#get_cell_fit_mode} directly in the new code.
     # @param row [Integer] 
@@ -1013,6 +1084,7 @@ module Wx::GRID
     alias_method :col_label_size, :get_col_label_size
     
     # Returns the minimal width to which a column may be resized.
+    # 
     # Use {Wx::GRID::Grid#set_col_minimal_acceptable_width} to change this value globally or {Wx::GRID::Grid#set_col_minimal_width} to do it for individual columns.
     # @see Wx::GRID::Grid#get_row_minimal_acceptable_height 
     # @return [Integer]
@@ -1032,6 +1104,7 @@ module Wx::GRID
     alias_method :col_shown?, :is_col_shown
     
     # Returns the default cell fitting mode.
+    # 
     # The default mode is "overflow", but can be modified using {Wx::GRID::Grid#set_default_cell_fit_mode}.
     # @see Wx::GRID::GridFitMode
     # @return [Wx::GRID::GridFitMode]
@@ -1039,6 +1112,7 @@ module Wx::GRID
     alias_method :default_cell_fit_mode, :get_default_cell_fit_mode
     
     # Returns true if the cells can overflow by default.
+    # 
     # This is identical to calling {Wx::GRID::Grid#get_default_cell_fit_mode} and using {Wx::GRID::GridFitMode#is_overflow} on the returned value.
     # Prefer using {Wx::GRID::Grid#get_default_cell_fit_mode} directly in the new code.
     # @return [Boolean]
@@ -1066,6 +1140,7 @@ module Wx::GRID
     alias_method :default_row_size, :get_default_row_size
     
     # Returns the minimal size to which rows can be resized.
+    # 
     # Use {Wx::GRID::Grid#set_row_minimal_acceptable_height} to change this value globally or {Wx::GRID::Grid#set_row_minimal_height} to do it for individual cells.
     # @see Wx::GRID::Grid#get_col_minimal_acceptable_width 
     # @return [Integer]
@@ -1091,6 +1166,7 @@ module Wx::GRID
     
     # Specifies the behaviour of the cell contents if it doesn't fit into the available space.
     # 
+    # 
     # @see Wx::GRID::GridFitMode
     # @param row [Integer] 
     # @param col [Integer] 
@@ -1099,6 +1175,7 @@ module Wx::GRID
     def set_cell_fit_mode(row, col, fitMode) end
     
     # Sets the overflow permission of the cell.
+    # 
     # Prefer using {Wx::GRID::Grid#set_cell_fit_mode} in the new code.
     # @param row [Integer] 
     # @param col [Integer] 
@@ -1107,6 +1184,7 @@ module Wx::GRID
     def set_cell_overflow(row, col, allow) end
     
     # Sets the height of the column labels.
+    # 
     # If height equals to {Wx::GRID::GRID_AUTOSIZE} then height is calculated automatically so that no label is truncated. Note that this could be slow for a large table.
     # @param height [Integer] 
     # @return [void]
@@ -1115,6 +1193,7 @@ module Wx::GRID
     
     # Sets the minimal width to which the user can resize columns.
     # 
+    # 
     # @see Wx::GRID::Grid#get_col_minimal_acceptable_width 
     # @param width [Integer] 
     # @return [void]
@@ -1122,6 +1201,7 @@ module Wx::GRID
     alias_method :col_minimal_acceptable_width=, :set_col_minimal_acceptable_width
     
     # Sets the minimal width for the specified column col.
+    # 
     # It is usually best to call this method during grid creation as calling it later will not resize the column to the given minimal width even if it is currently narrower than it.
     # width must be greater than the minimal acceptable column width as returned by {Wx::GRID::Grid#get_col_minimal_acceptable_width}.
     # @param col [Integer] 
@@ -1136,6 +1216,7 @@ module Wx::GRID
     def set_col_size(col, width) end
     
     # Hides the specified column.
+    # 
     # To show the column later you need to call {Wx::GRID::Grid#set_col_size} with non-0 width or {Wx::GRID::Grid#show_col} to restore the previous column width.
     # If the column is already hidden, this method doesn't do anything.
     # @param col [Integer]  The column index.
@@ -1143,6 +1224,7 @@ module Wx::GRID
     def hide_col(col) end
     
     # Shows the previously hidden column by resizing it to non-0 size.
+    # 
     # The column is shown again with the same width that it had before {Wx::GRID::Grid#hide_col} call.
     # If the column is currently shown, this method doesn't do anything.
     # @see Wx::GRID::Grid#hide_col
@@ -1153,6 +1235,7 @@ module Wx::GRID
     
     # Specifies the default behaviour of the cell contents if it doesn't fit into the available space.
     # 
+    # 
     # @see Wx::GRID::GridFitMode
     # @param fitMode [Wx::GRID::GridFitMode] 
     # @return [void]
@@ -1160,6 +1243,7 @@ module Wx::GRID
     alias_method :default_cell_fit_mode=, :set_default_cell_fit_mode
     
     # Sets the default overflow permission of the cells.
+    # 
     # Prefer using {Wx::GRID::Grid#set_default_cell_fit_mode} in the new code.
     # @param allow [Boolean] 
     # @return [void]
@@ -1167,6 +1251,7 @@ module Wx::GRID
     alias_method :default_cell_overflow=, :set_default_cell_overflow
     
     # Sets the default width for columns in the grid.
+    # 
     # This will only affect columns subsequently added to the grid unless resizeExistingCols is true.
     # If width is less than {Wx::GRID::Grid#get_col_minimal_acceptable_width}, then the minimal acceptable width is used instead of it.
     # @param width [Integer] 
@@ -1176,6 +1261,7 @@ module Wx::GRID
     alias_method :default_col_size=, :set_default_col_size
     
     # Sets the default height for rows in the grid.
+    # 
     # This will only affect rows subsequently added to the grid unless resizeExistingRows is true.
     # If height is less than {Wx::GRID::Grid#get_row_minimal_acceptable_height}, then the minimal acceptable height is used instead of it.
     # @param height [Integer] 
@@ -1185,6 +1271,7 @@ module Wx::GRID
     alias_method :default_row_size=, :set_default_row_size
     
     # Sets the width of the row labels.
+    # 
     # If width equals {Wx::GRID::GRID_AUTOSIZE} then width is calculated automatically so that no label is truncated. Note that this could be slow for a large table.
     # @param width [Integer] 
     # @return [void]
@@ -1192,6 +1279,7 @@ module Wx::GRID
     alias_method :row_label_size=, :set_row_label_size
     
     # Sets the minimal row height used by default.
+    # 
     # See {Wx::GRID::Grid#set_col_minimal_acceptable_width} for more information.
     # @param height [Integer] 
     # @return [void]
@@ -1199,6 +1287,7 @@ module Wx::GRID
     alias_method :row_minimal_acceptable_height=, :set_row_minimal_acceptable_height
     
     # Sets the minimal height for the specified row.
+    # 
     # See {Wx::GRID::Grid#set_col_minimal_width} for more information.
     # @param row [Integer] 
     # @param height [Integer] 
@@ -1206,6 +1295,7 @@ module Wx::GRID
     def set_row_minimal_height(row, height) end
     
     # Sets the height of the specified row.
+    # 
     # See {Wx::GRID::Grid#set_col_size} for more information.
     # @param row [Integer] 
     # @param height [Integer] 
@@ -1213,6 +1303,7 @@ module Wx::GRID
     def set_row_size(row, height) end
     
     # Hides the specified row.
+    # 
     # To show the row later you need to call {Wx::GRID::Grid#set_row_size} with non-0 width or {Wx::GRID::Grid#show_row} to restore its original height.
     # If the row is already hidden, this method doesn't do anything.
     # @param col [Integer]  The row index.
@@ -1220,6 +1311,7 @@ module Wx::GRID
     def hide_row(col) end
     
     # Shows the previously hidden row.
+    # 
     # The row is shown again with the same height that it had before {Wx::GRID::Grid#hide_row} call.
     # If the row is currently shown, this method doesn't do anything.
     # @see Wx::GRID::Grid#hide_row
@@ -1229,6 +1321,7 @@ module Wx::GRID
     def show_row(col) end
     
     # Get size information for all columns at once.
+    # 
     # This method is useful when the information about all column widths needs to be saved. The widths can be later restored using {Wx::GRID::Grid#set_col_sizes}.
     # @see Wx::GRID::GridSizesInfo
     # @see  Wx::GRID::Grid#get_row_sizes 
@@ -1238,6 +1331,7 @@ module Wx::GRID
     
     # Get size information for all row at once.
     # 
+    # 
     # @see Wx::GRID::GridSizesInfo
     # @see  Wx::GRID::Grid#get_col_sizes 
     # @return [Wx::GRID::GridSizesInfo]
@@ -1245,6 +1339,7 @@ module Wx::GRID
     alias_method :row_sizes, :get_row_sizes
     
     # Restore all columns sizes.
+    # 
     # This is usually called with {Wx::GRID::GridSizesInfo} object previously returned by {Wx::GRID::Grid#get_col_sizes}.
     # @see Wx::GRID::Grid#set_row_sizes 
     # @param sizeInfo [Wx::GRID::GridSizesInfo] 
@@ -1254,6 +1349,7 @@ module Wx::GRID
     
     # Restore all rows sizes.
     # 
+    # 
     # @see Wx::GRID::Grid#set_col_sizes 
     # @param sizeInfo [Wx::GRID::GridSizesInfo] 
     # @return [void]
@@ -1261,6 +1357,7 @@ module Wx::GRID
     alias_method :row_sizes=, :set_row_sizes
     
     # Set the size of the cell.
+    # 
     # Specifying a value of more than 1 in num_rows or num_cols will make the cell at (row, col) span the block of the specified size, covering the other cells which would be normally shown in it. Passing 1 for both arguments resets the cell to normal appearance.
     # @see Wx::GRID::Grid#get_cell_size
     # @param row [Integer]  The row of the cell.
@@ -1272,6 +1369,7 @@ module Wx::GRID
     
     # @overload get_cell_size(row, col)
     #   Get the size of the cell in number of cells covered by it.
+    #   
     #   For normal cells, the function fills both num_rows and num_cols with 1 and returns CellSpan_None. For cells which span multiple cells, i.e. for which {Wx::GRID::Grid#set_cell_size} had been called, the returned values are the same ones as were passed to {Wx::GRID::Grid#set_cell_size} call and the function return value is CellSpan_Main.
     #   More unexpectedly, perhaps, the returned values may be negative for the cells which are inside a span covered by a cell occupying multiple rows or columns. They correspond to the offset of the main cell of the span from the cell passed to this functions and the function returns CellSpan_Inside value to indicate this.
     #   As an example, consider a 3*3 grid with the cell (1, 1) (the one in the middle) having a span of 2 rows and 2 columns, i.e. the grid looks like 
@@ -1289,9 +1387,10 @@ module Wx::GRID
     #   The kind of this cell span (the return value is new in wxWidgets 2.9.1, this function was void in previous wxWidgets versions).
     #   @param row [Integer]  The row of the cell.
     #   @param col [Integer]  The column of the cell.
-    #   @return [Array(Wx::wxGrid::CellSpan,Integer,Integer)]
+    #   @return [Array(Wx::Grid::CellSpan,Integer,Integer)]
     # @overload get_cell_size(coords)
     #   Get the number of rows and columns allocated for this cell.
+    #   
     #   This overload doesn't return a CellSpan value but the values returned may still be negative, see GetCellSize(int, int, int *, int *) for details.
     #   @param coords [Array(Integer, Integer)] 
     #   @return [Wx::Size]
@@ -1304,12 +1403,14 @@ module Wx::GRID
     alias_method :can_drag_cell?, :can_drag_cell
     
     # Returns true if columns can be moved by dragging with the mouse.
+    # 
     # Columns can be moved by dragging on their labels.
     # @return [Boolean]
     def can_drag_col_move; end
     alias_method :can_drag_col_move?, :can_drag_col_move
     
     # Returns true if the given column can be resized by dragging with the mouse.
+    # 
     # This function returns true if resizing the columns interactively is globally enabled, i.e. if {Wx::GRID::Grid#disable_drag_col_size} hadn't been called, and if this column wasn't explicitly marked as non-resizable with {Wx::GRID::Grid#disable_col_resize}.
     # @param col [Integer] 
     # @return [Boolean]
@@ -1318,6 +1419,7 @@ module Wx::GRID
     
     # Return true if column edges inside the grid can be dragged to resize the rows.
     # 
+    # 
     # @see Wx::GRID::Grid#can_drag_grid_size
     # @see  Wx::GRID::Grid#can_drag_col_size
     # @return [Boolean]
@@ -1326,6 +1428,7 @@ module Wx::GRID
     
     # Return true if row edges inside the grid can be dragged to resize the rows.
     # 
+    # 
     # @see Wx::GRID::Grid#can_drag_grid_size
     # @see  Wx::GRID::Grid#can_drag_row_size
     # @return [Boolean]
@@ -1338,12 +1441,14 @@ module Wx::GRID
     alias_method :can_drag_grid_size?, :can_drag_grid_size
     
     # Returns true if rows can be moved by dragging with the mouse.
+    # 
     # Rows can be moved by dragging on their labels.
     # @return [Boolean]
     def can_drag_row_move; end
     alias_method :can_drag_row_move?, :can_drag_row_move
     
     # Returns true if the given row can be resized by dragging with the mouse.
+    # 
     # This is the same as {Wx::GRID::Grid#can_drag_col_size} but for rows.
     # @param row [Integer] 
     # @return [Boolean]
@@ -1356,6 +1461,7 @@ module Wx::GRID
     alias_method :can_hide_columns?, :can_hide_columns
     
     # Disable interactive resizing of the specified column.
+    # 
     # This method allows one to disable resizing of an individual column in a grid where the columns are otherwise resizable (which is the case by default).
     # Notice that currently there is no way to make some columns resizable in a grid where columns can't be resized by default as there doesn't seem to be any need for this in practice. There is also no way to make the column marked as fixed using this method resizable again because it is supposed that fixed columns are used for static parts of the grid and so should remain fixed during the entire grid lifetime.
     # Also notice that disabling interactive column resizing will not prevent the program from changing the column size.
@@ -1365,6 +1471,7 @@ module Wx::GRID
     def disable_col_resize(col) end
     
     # Disable interactive resizing of the specified row.
+    # 
     # This is the same as {Wx::GRID::Grid#disable_col_resize} but for rows.
     # @see Wx::GRID::Grid#enable_drag_row_size 
     # @param row [Integer] 
@@ -1372,31 +1479,37 @@ module Wx::GRID
     def disable_row_resize(row) end
     
     # Disables column moving by dragging with the mouse.
+    # 
     # Equivalent to passing false to {Wx::GRID::Grid#enable_drag_col_move}.
     # @return [void]
     def disable_drag_col_move; end
     
     # Disables row moving by dragging with the mouse.
+    # 
     # Equivalent to passing false to {Wx::GRID::Grid#enable_drag_row_move}.
     # @return [void]
     def disable_drag_row_move; end
     
     # Disables column sizing by dragging with the mouse.
+    # 
     # Equivalent to passing false to {Wx::GRID::Grid#enable_drag_col_size}.
     # @return [void]
     def disable_drag_col_size; end
     
     # Disable mouse dragging of grid lines to resize rows and columns.
+    # 
     # Equivalent to passing false to {Wx::GRID::Grid#enable_drag_grid_size}
     # @return [void]
     def disable_drag_grid_size; end
     
     # Disables row sizing by dragging with the mouse.
+    # 
     # Equivalent to passing false to {Wx::GRID::Grid#enable_drag_row_size}.
     # @return [void]
     def disable_drag_row_size; end
     
     # Disables column hiding from the header popup menu.
+    # 
     # Equivalent to passing false to {Wx::GRID::Grid#enable_hiding_columns}.
     # @return [void]
     def disable_hiding_columns; end
@@ -1407,12 +1520,14 @@ module Wx::GRID
     def enable_drag_cell(enable=true) end
     
     # Enables or disables column moving by dragging with the mouse.
+    # 
     # Note that reordering columns by dragging them is currently not supported when the grid has any frozen columns (see {Wx::GRID::Grid#freeze_to}) and if this method is called with enable equal to true in this situation, it returns false without doing anything. Otherwise it returns true to indicate that it was successful.
     # @param enable [Boolean] 
     # @return [Boolean]
     def enable_drag_col_move(enable=true) end
     
     # Enables or disables row moving by dragging with the mouse.
+    # 
     # Note that reordering rows by dragging them is currently not supported when the grid has any frozen columns (see {Wx::GRID::Grid#freeze_to}) and if this method is called with enable equal to true in this situation, it returns false without doing anything. Otherwise it returns true to indicate that it was successful.
     # @param enable [Boolean] 
     # @return [Boolean]
@@ -1420,6 +1535,7 @@ module Wx::GRID
     
     # Enables or disables column sizing by dragging with the mouse.
     # 
+    # 
     # @see Wx::GRID::Grid#disable_col_resize 
     # @param enable [Boolean] 
     # @return [void]
@@ -1432,12 +1548,14 @@ module Wx::GRID
     
     # Enables or disables row sizing by dragging with the mouse.
     # 
+    # 
     # @see Wx::GRID::Grid#disable_row_resize 
     # @param enable [Boolean] 
     # @return [void]
     def enable_drag_row_size(enable=true) end
     
     # Enables or disables column hiding from the header popup menu.
+    # 
     # Note that currently the popup menu can only be shown when using {Wx::HeaderCtrl}, i.e. if {Wx::GRID::Grid#use_native_col_header} had been called.
     # If the native header is not used, this method always simply returns false without doing anything, as hiding columns is not supported anyhow. If enable value is the same as {Wx::GRID::Grid#can_hide_columns}, it also returns false to indicate that nothing was done. Otherwise, it returns true to indicate that the value of this option was successfully changed.
     # The main use case for this method is to disallow hiding the columns interactively when using the native header.
@@ -1465,6 +1583,7 @@ module Wx::GRID
     def set_col_pos(colID, newPos) end
     
     # Sets the positions of all columns at once.
+    # 
     # This method takes an array containing the indices of the columns in their display order, i.e. uses the same convention as {Wx::HeaderCtrl#set_columns_order}.
     # @param order [Array<Integer>] 
     # @return [void]
@@ -1494,6 +1613,7 @@ module Wx::GRID
     def set_row_pos(rowID, newPos) end
     
     # Sets the positions of all rows at once.
+    # 
     # This method takes an array containing the indices of the rows in their display order.
     # @param order [Array<Integer>] 
     # @return [void]
@@ -1505,6 +1625,7 @@ module Wx::GRID
     def reset_row_pos; end
     
     # Returns the current grid cursor position.
+    # 
     # If grid cursor doesn't have any valid position (e.g. if the grid is completely empty and doesn't have any rows or columns), returns {Wx::GridNoCellCoords} which has both row and columns set to <code>-1</code>.
     # @return [Array(Integer, Integer)]
     def get_grid_cursor_coords; end
@@ -1512,6 +1633,7 @@ module Wx::GRID
     
     # Returns the current grid cell column position.
     # 
+    # 
     # @see Wx::GRID::Grid#get_grid_cursor_coords 
     # @return [Integer]
     def get_grid_cursor_col; end
@@ -1519,6 +1641,7 @@ module Wx::GRID
     
     # Returns the current grid cell row position.
     # 
+    # 
     # @see Wx::GRID::Grid#get_grid_cursor_coords 
     # @return [Integer]
     def get_grid_cursor_row; end
@@ -1526,60 +1649,70 @@ module Wx::GRID
     
     # @overload go_to_cell(row, col)
     #   Make the given cell current and ensure it is visible.
+    #   
     #   This method is equivalent to calling {Wx::GRID::Grid#make_cell_visible} and {Wx::GRID::Grid#set_grid_cursor} and so, as with the latter, a {Wx::GRID::EVT_GRID_SELECT_CELL} event is generated by it and the selected cell doesn't change if the event is vetoed.
     #   @param row [Integer] 
     #   @param col [Integer] 
     #   @return [void]
     # @overload go_to_cell(coords)
     #   Make the given cell current and ensure it is visible.
+    #   
     #   This method is equivalent to calling {Wx::GRID::Grid#make_cell_visible} and {Wx::GRID::Grid#set_grid_cursor} and so, as with the latter, a {Wx::GRID::EVT_GRID_SELECT_CELL} event is generated by it and the selected cell doesn't change if the event is vetoed.
     #   @param coords [Array(Integer, Integer)] 
     #   @return [void]
     def go_to_cell(*args) end
     
     # Moves the grid cursor down by one row.
+    # 
     # If a block of cells was previously selected it will expand if the argument is true or be cleared if the argument is false.
     # @param expandSelection [Boolean] 
     # @return [Boolean]
     def move_cursor_down(expandSelection) end
     
     # Moves the grid cursor down in the current column such that it skips to the beginning or end of a block of non-empty cells.
+    # 
     # If a block of cells was previously selected it will expand if the argument is true or be cleared if the argument is false.
     # @param expandSelection [Boolean] 
     # @return [Boolean]
     def move_cursor_down_block(expandSelection) end
     
     # Moves the grid cursor left by one column.
+    # 
     # If a block of cells was previously selected it will expand if the argument is true or be cleared if the argument is false.
     # @param expandSelection [Boolean] 
     # @return [Boolean]
     def move_cursor_left(expandSelection) end
     
     # Moves the grid cursor left in the current row such that it skips to the beginning or end of a block of non-empty cells.
+    # 
     # If a block of cells was previously selected it will expand if the argument is true or be cleared if the argument is false.
     # @param expandSelection [Boolean] 
     # @return [Boolean]
     def move_cursor_left_block(expandSelection) end
     
     # Moves the grid cursor right by one column.
+    # 
     # If a block of cells was previously selected it will expand if the argument is true or be cleared if the argument is false.
     # @param expandSelection [Boolean] 
     # @return [Boolean]
     def move_cursor_right(expandSelection) end
     
     # Moves the grid cursor right in the current row such that it skips to the beginning or end of a block of non-empty cells.
+    # 
     # If a block of cells was previously selected it will expand if the argument is true or be cleared if the argument is false.
     # @param expandSelection [Boolean] 
     # @return [Boolean]
     def move_cursor_right_block(expandSelection) end
     
     # Moves the grid cursor up by one row.
+    # 
     # If a block of cells was previously selected it will expand if the argument is true or be cleared if the argument is false.
     # @param expandSelection [Boolean] 
     # @return [Boolean]
     def move_cursor_up(expandSelection) end
     
     # Moves the grid cursor up in the current column such that it skips to the beginning or end of a block of non-empty cells.
+    # 
     # If a block of cells was previously selected it will expand if the argument is true or be cleared if the argument is false.
     # @param expandSelection [Boolean] 
     # @return [Boolean]
@@ -1595,6 +1728,7 @@ module Wx::GRID
     
     # @overload set_grid_cursor(row, col)
     #   Set the grid cursor to the specified cell.
+    #   
     #   The grid cursor indicates the current cell and can be moved by the user using the arrow keys or the mouse.
     #   Calling this function generates a {Wx::GRID::EVT_GRID_SELECT_CELL} event and if the event handler vetoes this event, the cursor is not moved.
     #   This function doesn't make the target call visible, use {Wx::GRID::Grid#go_to_cell} to do this.
@@ -1603,6 +1737,7 @@ module Wx::GRID
     #   @return [void]
     # @overload set_grid_cursor(coords)
     #   Set the grid cursor to the specified cell.
+    #   
     #   The grid cursor indicates the current cell and can be moved by the user using the arrow keys or the mouse.
     #   Calling this function generates a {Wx::GRID::EVT_GRID_SELECT_CELL} event and if the event handler vetoes this event, the cursor is not moved.
     #   This function doesn't make the target call visible, use {Wx::GRID::Grid#go_to_cell} to do this.
@@ -1612,10 +1747,11 @@ module Wx::GRID
     alias_method :grid_cursor=, :set_grid_cursor
     
     # Set the grid's behaviour when the user presses the TAB key.
+    # 
     # Pressing the TAB key moves the grid cursor right in the current row, if there is a cell at the right and, similarly, Shift-TAB moves the cursor to the left in the current row if it's not in the first column.
     # What happens if the cursor can't be moved because it it's already at the beginning or end of the row can be configured using this function, see {Wx::GRID::Grid::TabBehaviour} documentation for the detailed description.
     # IF none of the standard behaviours is appropriate, you can always handle {Wx::GRID::EVT_GRID_TABBING} event directly to implement a custom TAB-handling logic.
-    # @param behaviour [Wx::wxGrid::TabBehaviour] 
+    # @param behaviour [Wx::Grid::TabBehaviour] 
     # @return [void]
     def set_tab_behaviour(behaviour) end
     alias_method :tab_behaviour=, :set_tab_behaviour
@@ -1640,24 +1776,42 @@ module Wx::GRID
     # @return [void]
     def deselect_cell(row, col) end
     
+    # Returns a range of grid selection blocks.
+    # 
+    # The returned range can be iterated over, e.g. with C++11 range-for loop: 
+    # ```
+    #   for ( const auto block: grid->GetSelectedBlocks() ) {
+    #       if ( block.Intersects(myBlock) )
+    #           break;
+    #   }
+    # ```
+    # 
+    # Notice that the blocks returned by this method are not ordered in any particular way and may overlap. For grids using rows or columns-only selection modes, {Wx::GRID::Grid#get_selected_row_blocks} or {Wx::GRID::Grid#get_selected_col_blocks} can be more convenient, as they return ordered and non-overlapping blocks.
+    # @return [Array<Wx::GRID::GridBlockCoords>]
+    def get_selected_blocks; end
+    alias_method :selected_blocks, :get_selected_blocks
+    
     # Returns an ordered range of non-overlapping selected rows.
+    # 
     # For the grids using {Wx::GRID::Grid::GridSelectionModes::GridSelectRows} selection mode, returns the possibly empty vector containing the coordinates of non-overlapping selected row blocks in the natural order, i.e. from smallest to the biggest row indices.
     # To see the difference between this method and {Wx::GRID::Grid#get_selected_blocks}, consider the case when the user selects rows 2..4 in the grid and then also selects (using Ctrl/Shift keys) the rows 1..3. Iterating over the result of {Wx::GRID::Grid#get_selected_blocks} would yield two blocks directly corresponding to the users selection, while this method returns a vector with a single element corresponding to the rows 1..4.
     # This method returns empty vector for the other selection modes.
     # @see Wx::GRID::Grid#get_selected_blocks
     # @see  Wx::GRID::Grid#get_selected_col_blocks
-    # @return [Array<Wx::GRID::GridBlockCoords]
+    # @return [Array<Wx::GRID::GridBlockCoords>]
     def get_selected_row_blocks; end
     alias_method :selected_row_blocks, :get_selected_row_blocks
     
     # Returns an ordered range of non-overlapping selected columns.
+    # 
     # This method is symmetric to {Wx::GRID::Grid#get_selected_row_blocks}, but is useful only in {Wx::GRID::Grid::GridSelectionModes::GridSelectColumns} selection mode.
     # @see Wx::GRID::Grid#get_selected_blocks
-    # @return [Array<Wx::GRID::GridBlockCoords]
+    # @return [Array<Wx::GRID::GridBlockCoords>]
     def get_selected_col_blocks; end
     alias_method :selected_col_blocks, :get_selected_col_blocks
     
     # Returns an array of individually selected cells.
+    # 
     # Notice that this array does not contain all the selected cells in general as it doesn't include the cells selected as part of column, row or block selection. You must use this method, {Wx::GRID::Grid#get_selected_cols}, {Wx::GRID::Grid#get_selected_rows} and {Wx::GRID::Grid#get_selection_block_top_left} and {Wx::GRID::Grid#get_selection_block_bottom_right} methods to obtain the entire selection in general.
     # Please notice this behaviour is by design and is needed in order to support grids of arbitrary size (when an entire column is selected in a grid with a million of columns, we don't want to create an array with a million of entries in this function, instead it returns an empty array and {Wx::GRID::Grid#get_selected_cols} returns an array containing one element).
     # The function can be slow for the big grids, use {Wx::GRID::Grid#get_selected_blocks} in the new code.
@@ -1666,6 +1820,7 @@ module Wx::GRID
     alias_method :selected_cells, :get_selected_cells
     
     # Returns an array of selected columns.
+    # 
     # Please notice that this method alone is not sufficient to find all the selected columns as it contains only the columns which were individually selected but not those being part of the block selection or being selected in virtue of all of their cells being selected individually, please see {Wx::GRID::Grid#get_selected_cells} for more details.
     # The function can be slow for the big grids, use {Wx::GRID::Grid#get_selected_blocks} in the new code.
     # @return [Array<Integer>]
@@ -1673,6 +1828,7 @@ module Wx::GRID
     alias_method :selected_cols, :get_selected_cols
     
     # Returns an array of selected rows.
+    # 
     # Please notice that this method alone is not sufficient to find all the selected rows as it contains only the rows which were individually selected but not those being part of the block selection or being selected in virtue of all of their cells being selected individually, please see {Wx::GRID::Grid#get_selected_cells} for more details.
     # The function can be slow for the big grids, use {Wx::GRID::Grid#get_selected_blocks} in the new code.
     # @return [Array<Integer>]
@@ -1685,6 +1841,7 @@ module Wx::GRID
     alias_method :selection_background, :get_selection_background
     
     # Returns an array of the bottom right corners of blocks of selected cells.
+    # 
     # Please see {Wx::GRID::Grid#get_selected_cells} for more information about the selection representation in {Wx::GRID::Grid}.
     # The function can be slow for the big grids, use {Wx::GRID::Grid#get_selected_blocks} in the new code.
     # @see Wx::GRID::Grid#get_selection_block_top_left 
@@ -1693,6 +1850,7 @@ module Wx::GRID
     alias_method :selection_block_bottom_right, :get_selection_block_bottom_right
     
     # Returns an array of the top left corners of blocks of selected cells.
+    # 
     # Please see {Wx::GRID::Grid#get_selected_cells} for more information about the selection representation in {Wx::GRID::Grid}.
     # The function can be slow for the big grids, use {Wx::GRID::Grid#get_selected_blocks} in the new code.
     # @see Wx::GRID::Grid#get_selection_block_bottom_right 
@@ -1707,8 +1865,9 @@ module Wx::GRID
     
     # Returns the current selection mode.
     # 
+    # 
     # @see Wx::GRID::Grid#set_selection_mode. 
-    # @return [Wx::wxGrid::GridSelectionModes]
+    # @return [Wx::Grid::GridSelectionModes]
     def get_selection_mode; end
     alias_method :selection_mode, :get_selection_mode
     
@@ -1729,6 +1888,7 @@ module Wx::GRID
     def select_all; end
     
     # Selects a rectangular block of cells.
+    # 
     # If addToSelected is false then any existing selection will be deselected; if true the column will be added to the existing selection.
     # @param topRow [Integer] 
     # @param leftCol [Integer] 
@@ -1739,6 +1899,7 @@ module Wx::GRID
     def select_block(topRow, leftCol, bottomRow, rightCol, addToSelected=false) end
     
     # Selects the specified column.
+    # 
     # If addToSelected is false then any existing selection will be deselected; if true the column will be added to the existing selection.
     # This method won't select anything if the current selection mode is {Wx::GRID::Grid::GridSelectionModes::GridSelectRows}.
     # @param col [Integer] 
@@ -1747,6 +1908,7 @@ module Wx::GRID
     def select_col(col, addToSelected=false) end
     
     # Selects the specified row.
+    # 
     # If addToSelected is false then any existing selection will be deselected; if true the row will be added to the existing selection.
     # This method won't select anything if the current selection mode is {Wx::GRID::Grid::GridSelectionModes::GridSelectColumns}.
     # @param row [Integer] 
@@ -1767,13 +1929,15 @@ module Wx::GRID
     alias_method :selection_foreground=, :set_selection_foreground
     
     # Set the selection behaviour of the grid.
+    # 
     # The existing selection is converted to conform to the new mode if possible and discarded otherwise (e.g. any individual selected cells are deselected if the new mode allows only the selection of the entire rows or columns).
-    # @param selmode [Wx::wxGrid::GridSelectionModes] 
+    # @param selmode [Wx::Grid::GridSelectionModes] 
     # @return [void]
     def set_selection_mode(selmode) end
     alias_method :selection_mode=, :set_selection_mode
     
     # Returns the number of pixels per horizontal scroll increment.
+    # 
     # The default is 15.
     # @see Wx::GRID::Grid#get_scroll_line_y
     # @see  Wx::GRID::Grid#set_scroll_line_x
@@ -1783,6 +1947,7 @@ module Wx::GRID
     alias_method :scroll_line_x, :get_scroll_line_x
     
     # Returns the number of pixels per vertical scroll increment.
+    # 
     # The default is 15.
     # @see Wx::GRID::Grid#get_scroll_line_x
     # @see  Wx::GRID::Grid#set_scroll_line_x
@@ -1792,6 +1957,7 @@ module Wx::GRID
     alias_method :scroll_line_y, :get_scroll_line_y
     
     # Returns true if a cell is either entirely or at least partially visible in the grid window.
+    # 
     # By default, the cell must be entirely visible for this function to return true but if wholeCellVisible is false, the function returns true even if the cell is only partially visible.
     # @param row [Integer] 
     # @param col [Integer] 
@@ -1801,6 +1967,7 @@ module Wx::GRID
     alias_method :visible?, :is_visible
     
     # Brings the specified cell into the visible grid cell area with minimal scrolling.
+    # 
     # Does nothing if the cell is already visible.
     # @param row [Integer] 
     # @param col [Integer] 
@@ -1808,18 +1975,21 @@ module Wx::GRID
     def make_cell_visible(row, col) end
     
     # Returns the topmost row of the current visible area.
+    # 
     # Returns -1 if the grid doesn't have any rows.
     # @return [Integer]
     def get_first_fully_visible_row; end
     alias_method :first_fully_visible_row, :get_first_fully_visible_row
     
     # Returns the leftmost column of the current visible area.
+    # 
     # Returns -1 if the grid doesn't have any columns.
     # @return [Integer]
     def get_first_fully_visible_column; end
     alias_method :first_fully_visible_column, :get_first_fully_visible_column
     
     # Sets the number of pixels per horizontal scroll increment.
+    # 
     # The default is 15.
     # @see Wx::GRID::Grid#get_scroll_line_x
     # @see  Wx::GRID::Grid#get_scroll_line_y
@@ -1830,6 +2000,7 @@ module Wx::GRID
     alias_method :scroll_line_x=, :set_scroll_line_x
     
     # Sets the number of pixels per vertical scroll increment.
+    # 
     # The default is 15.
     # @see Wx::GRID::Grid#get_scroll_line_x
     # @see  Wx::GRID::Grid#get_scroll_line_y
@@ -1840,6 +2011,7 @@ module Wx::GRID
     alias_method :scroll_line_y=, :set_scroll_line_y
     
     # Convert grid cell coordinates to grid window pixel coordinates.
+    # 
     # This function returns the rectangle that encloses the block of cells limited by topLeft and bottomRight cell in device coords and clipped to the client size of the grid window.
     # @see Wx::GRID::Grid#cell_to_rect 
     # @param topLeft [Array(Integer, Integer)] 
@@ -1850,6 +2022,7 @@ module Wx::GRID
     
     # Return the rectangle corresponding to the grid cell's size and position in logical coordinates.
     # 
+    # 
     # @see Wx::GRID::Grid#block_to_device_rect 
     # @param row [Integer] 
     # @param col [Integer] 
@@ -1858,6 +2031,7 @@ module Wx::GRID
     
     # @overload cell_to_grid_window(row, col)
     #   Returns the grid window that contains the cell.
+    #   
     #   In a grid without frozen rows or columns (see {Wx::GRID::Grid#freeze_to}), this will always return the same window as {Wx::GRID::Grid#get_grid_window}, however if some parts of the grid are frozen, this function returns the window containing the given cell.
     #   @param row [Integer] 
     #   @param col [Integer] 
@@ -1898,6 +2072,7 @@ module Wx::GRID
     def calc_grid_window_scrolled_position(pt, gridWindow) end
     
     # Returns the column at the given pixel position depending on the window.
+    # 
     # The column index or {Wx::NOT_FOUND}.
     # @param x [Integer]  The x position to evaluate.
     # @param clipToMinMax [Boolean]  If true, rather than returning {Wx::NOT_FOUND}, it returns either the first or last column depending on whether x is too far to the left or right respectively.
@@ -1906,6 +2081,7 @@ module Wx::GRID
     def x_to_col(x, clipToMinMax=false, gridWindow=nil) end
     
     # Returns the column whose right hand edge is close to the given logical x position.
+    # 
     # If no column edge is near to this position {Wx::NOT_FOUND} is returned.
     # @param x [Integer] 
     # @return [Integer]
@@ -1913,6 +2089,7 @@ module Wx::GRID
     
     # @overload xy_to_cell(x, y, gridWindow=nil)
     #   Translates logical pixel coordinates to the grid cell coordinates.
+    #   
     #   Notice that this function expects logical coordinates on input so if you use this function in a mouse event handler you need to translate the mouse position, which is expressed in device coordinates, to logical ones.
     #   The parameter gridWindow is new since wxWidgets 3.1.3. If it is specified, i.e. non-NULL, the coordinates must be in this window coordinate system and only the cells of this window are considered, i.e. the function returns {Wx::NOT_FOUND} if the coordinates are out of bounds.
     #   If gridWindow is NULL, coordinates are relative to the main grid window and all cells are considered.
@@ -1930,12 +2107,14 @@ module Wx::GRID
     def xy_to_cell(*args) end
     
     # Returns the row whose bottom edge is close to the given logical y position.
+    # 
     # If no row edge is near to this position {Wx::NOT_FOUND} is returned.
     # @param y [Integer] 
     # @return [Integer]
     def y_to_edge_of_row(y) end
     
     # Returns the grid row that corresponds to the logical y coordinate.
+    # 
     # The parameter gridWindow is new since wxWidgets 3.1.3. If it is specified, i.e. non-NULL, only the cells of this window are considered, i.e. the function returns {Wx::NOT_FOUND} if y is out of bounds.
     # If gridWindow is NULL, the function returns {Wx::NOT_FOUND} only if there is no row at all at the y position.
     # @param y [Integer] 
@@ -1945,6 +2124,7 @@ module Wx::GRID
     def y_to_row(y, clipToMinMax=false, gridWindow=nil) end
     
     # Appends one or more new columns to the right of the grid.
+    # 
     # The updateLabels argument is not used at present. If you are using a derived grid table class you will need to override {Wx::GRID::GridTableBase#append_cols}. See {Wx::GRID::Grid#insert_cols} for further information.
     # true on success or false if appending columns failed.
     # @param numCols [Integer] 
@@ -1953,6 +2133,7 @@ module Wx::GRID
     def append_cols(numCols=1, updateLabels=true) end
     
     # Appends one or more new rows to the bottom of the grid.
+    # 
     # The updateLabels argument is not used at present. If you are using a derived grid table class you will need to override {Wx::GRID::GridTableBase#append_rows}. See {Wx::GRID::Grid#insert_rows} for further information.
     # true on success or false if appending rows failed.
     # @param numRows [Integer] 
@@ -1961,6 +2142,7 @@ module Wx::GRID
     def append_rows(numRows=1, updateLabels=true) end
     
     # Return true if the horizontal grid lines stop at the last column boundary or false if they continue to the end of the window.
+    # 
     # The default is to clip grid lines.
     # @see Wx::GRID::Grid#clip_horz_grid_lines
     # @see  Wx::GRID::Grid#are_vert_grid_lines_clipped 
@@ -1968,6 +2150,7 @@ module Wx::GRID
     def are_horz_grid_lines_clipped; end
     
     # Return true if the vertical grid lines stop at the last row boundary or false if they continue to the end of the window.
+    # 
     # The default is to clip grid lines.
     # @see Wx::GRID::Grid#clip_vert_grid_lines
     # @see  Wx::GRID::Grid#are_horz_grid_lines_clipped 
@@ -1975,17 +2158,20 @@ module Wx::GRID
     def are_vert_grid_lines_clipped; end
     
     # Increments the grid's batch count.
+    # 
     # When the count is greater than zero repainting of the grid is suppressed. Each call to BeginBatch must be matched by a later call to {Wx::GRID::Grid#end_batch}. Code that does a lot of grid modification can be enclosed between {Wx::GRID::Grid#begin_batch} and {Wx::GRID::Grid#end_batch} calls to avoid screen flicker. The final {Wx::GRID::Grid#end_batch} call will cause the grid to be repainted.
     # Notice that you should use {Wx::GridUpdateLocker} which ensures that there is always a matching {Wx::GRID::Grid#end_batch} call for this {Wx::GRID::Grid#begin_batch} if possible instead of calling this method directly.
     # @return [void]
     def begin_batch; end
     
     # Clears all data in the underlying grid table and repaints the grid.
+    # 
     # The table is not deleted by this function. If you are using a derived table class then you need to override {Wx::GRID::GridTableBase#clear} for this function to have any effect.
     # @return [void]
     def clear_grid; end
     
     # Change whether the horizontal grid lines are clipped by the end of the last column.
+    # 
     # By default the grid lines are not drawn beyond the end of the last column but after calling this function with clip set to false they will be drawn across the entire grid window.
     # @see Wx::GRID::Grid#are_horz_grid_lines_clipped
     # @see  Wx::GRID::Grid#clip_vert_grid_lines 
@@ -1994,6 +2180,7 @@ module Wx::GRID
     def clip_horz_grid_lines(clip) end
     
     # Change whether the vertical grid lines are clipped by the end of the last row.
+    # 
     # By default the grid lines are not drawn beyond the end of the last row but after calling this function with clip set to false they will be drawn across the entire grid window.
     # @see Wx::GRID::Grid#are_vert_grid_lines_clipped
     # @see  Wx::GRID::Grid#clip_horz_grid_lines 
@@ -2002,6 +2189,7 @@ module Wx::GRID
     def clip_vert_grid_lines(clip) end
     
     # Deletes one or more columns from a grid starting at the specified position.
+    # 
     # The updateLabels argument is not used at present. If you are using a derived grid table class you will need to override {Wx::GRID::GridTableBase#delete_cols}. See {Wx::GRID::Grid#insert_cols} for further information.
     # true on success or false if deleting columns failed.
     # @param pos [Integer] 
@@ -2011,6 +2199,7 @@ module Wx::GRID
     def delete_cols(pos=0, numCols=1, updateLabels=true) end
     
     # Deletes one or more rows from a grid starting at the specified position.
+    # 
     # The updateLabels argument is not used at present. If you are using a derived grid table class you will need to override {Wx::GRID::GridTableBase#delete_rows}. See {Wx::GRID::Grid#insert_rows} for further information.
     # true on success or false if deleting rows failed.
     # @param pos [Integer] 
@@ -2021,6 +2210,7 @@ module Wx::GRID
     
     # @overload freeze_to(row, col)
     #   Sets or resets the frozen columns and rows.
+    #   
     #   true on success or false if it failed.
     #   
     #   Note that this method doesn't do anything, and returns false, if any of the following conditions are true:
@@ -2041,6 +2231,7 @@ module Wx::GRID
     def freeze_to(*args) end
     
     # Decrements the grid's batch count.
+    # 
     # When the count is greater than zero repainting of the grid is suppressed. Each previous call to {Wx::GRID::Grid#begin_batch} must be matched by a later call to {Wx::GRID::Grid#end_batch}. Code that does a lot of grid modification can be enclosed between {Wx::GRID::Grid#begin_batch} and {Wx::GRID::Grid#end_batch} calls to avoid screen flicker. The final {Wx::GRID::Grid#end_batch} will cause the grid to be repainted.
     # @see Wx::GridUpdateLocker 
     # @return [void]
@@ -2051,29 +2242,34 @@ module Wx::GRID
     def fit; end
     
     # Causes immediate repainting of the grid.
+    # 
     # Use this instead of the usual {Wx::Window#refresh}.
     # @return [void]
     def force_refresh; end
     
     # Returns the number of times that {Wx::GRID::Grid#begin_batch} has been called without (yet) matching calls to {Wx::GRID::Grid#end_batch}.
+    # 
     # While the grid's batch count is greater than zero the display will not be updated.
     # @return [Integer]
     def get_batch_count; end
     alias_method :batch_count, :get_batch_count
     
     # Returns the total number of grid columns.
+    # 
     # This is the same as the number of columns in the underlying grid table.
     # @return [Integer]
     def get_number_cols; end
     alias_method :number_cols, :get_number_cols
     
     # Returns the total number of grid rows.
+    # 
     # This is the same as the number of rows in the underlying grid table.
     # @return [Integer]
     def get_number_rows; end
     alias_method :number_rows, :get_number_rows
     
     # Returns the number of frozen grid columns.
+    # 
     # If there are no frozen columns, returns 0.
     # @see Wx::GRID::Grid#freeze_to 
     # @return [Integer]
@@ -2081,6 +2277,7 @@ module Wx::GRID
     alias_method :number_frozen_cols, :get_number_frozen_cols
     
     # Returns the number of frozen grid rows.
+    # 
     # If there are no frozen rows, returns 0.
     # @see Wx::GRID::Grid#freeze_to 
     # @return [Integer]
@@ -2088,6 +2285,7 @@ module Wx::GRID
     alias_method :number_frozen_rows, :get_number_frozen_rows
     
     # Returns the attribute for the given cell creating one if necessary.
+    # 
     # If the cell already has an attribute, it is returned. Otherwise a new attribute is created, associated with the cell and returned. In any case the caller must call DecRef() on the returned pointer.
     # Prefer to use {Wx::GRID::Grid#get_or_create_cell_attr_ptr} to avoid the need to call DecRef() on the returned pointer.
     # This function may only be called if {Wx::GRID::Grid#can_have_attributes} returns true.
@@ -2098,12 +2296,14 @@ module Wx::GRID
     alias_method :or_create_cell_attr, :get_or_create_cell_attr
     
     # Returns a base pointer to the current table object.
+    # 
     # The returned pointer is still owned by the grid.
     # @return [Wx::GRID::GridTableBase]
     def get_table; end
     alias_method :table, :get_table
     
     # Inserts one or more new columns into a grid with the first new column at the specified position.
+    # 
     # Notice that inserting the columns in the grid requires grid table cooperation: when this method is called, grid object begins by requesting the underlying grid table to insert new columns. If this is successful the table notifies the grid and the grid updates the display. For a default grid (one where you have called {Wx::GRID::Grid#create_grid}) this process is automatic. If you are using a custom grid table (specified with {Wx::GRID::Grid#set_table} or {Wx::GRID::Grid#assign_table}) then you must override {Wx::GRID::GridTableBase#insert_cols} in your derived table class.
     # 
     # true if the columns were successfully inserted, false if an error occurred (most likely the table couldn't be updated).
@@ -2114,6 +2314,7 @@ module Wx::GRID
     def insert_cols(pos=0, numCols=1, updateLabels=true) end
     
     # Inserts one or more new rows into a grid with the first new row at the specified position.
+    # 
     # Notice that you must implement {Wx::GRID::GridTableBase#insert_rows} if you use a grid with a custom table, please see {Wx::GRID::Grid#insert_cols} for more information.
     # 
     # true if the rows were successfully inserted, false if an error occurred (most likely the table couldn't be updated).
@@ -2124,6 +2325,7 @@ module Wx::GRID
     def insert_rows(pos=0, numRows=1, updateLabels=true) end
     
     # Invalidates the cached attribute for the given cell.
+    # 
     # For efficiency reasons, {Wx::GRID::Grid} may cache the recently used attributes (currently it caches only the single most recently used one, in fact) which can result in the cell appearance not being refreshed even when the attribute returned by your custom {Wx::GridCellAttrProvider}-derived class has changed. To force the grid to refresh the cell attribute, this function may be used. Notice that calling it will not result in actually redrawing the cell, you still need to call {Wx::Window#refresh_rect} to invalidate the area occupied by the cell in the window to do this. Also note that you don't need to call this function if you store the attributes in {Wx::GRID::Grid} itself, i.e. use its {Wx::GRID::Grid#set_attr} and similar methods, it is only useful when using a separate custom attributes provider.
     # @param row [Integer]  The row of the cell whose attribute needs to be queried again.
     # @param col [Integer]  The column of the cell whose attribute needs to be queried again.
@@ -2132,6 +2334,7 @@ module Wx::GRID
     
     # @overload refresh_block(topLeft, bottomRight)
     #   Redraw all the cells in the given block.
+    #   
     #   Refresh the block of cells with the given corners.
     #   If the bottom right corner coordinates are invalid, i.e. set to <code>-1</code>, the top left corner coordinates are used for it, i.e. just a single cell is refreshed. If the top left corner coordinates are invalid as well, the function simply returns without doing anything. Note, however, that both coordinates need to be valid or invalid simultaneously, i.e. setting the top row to <code>-1</code> but using a valid value for the left column is unsupported and would result in an assertion failure.
     #   @param topLeft [Array(Integer, Integer)] 
@@ -2147,6 +2350,7 @@ module Wx::GRID
     def refresh_block(*args) end
     
     # Draws part or all of a {Wx::GRID::Grid} on a {Wx::DC} for printing or display.
+    # 
     # Pagination can be accomplished by using sequential {Wx::GRID::Grid#render} calls with appropriate values in {Wx::GridCellCoords} topLeft and bottomRight.
     # @param dc [Wx::DC]  The {Wx::DC} to be drawn on.
     # @param pos [Array(Integer, Integer), Wx::Point]  The position on the {Wx::DC} where rendering should begin. If not specified drawing will begin at the {Wx::DC} MaxX() and MaxY().
@@ -2158,6 +2362,7 @@ module Wx::GRID
     def render(dc, pos=Wx::DEFAULT_POSITION, size=Wx::DEFAULT_SIZE, topLeft=(Wx::GridCellCoords.new(-1, -1)), bottomRight=(Wx::GridCellCoords.new(-1, -1)), style=Wx::GRID::GridRenderStyle::GRID_DRAW_DEFAULT) end
     
     # Sets the cell attributes for the specified cell.
+    # 
     # The grid takes ownership of the attribute pointer.
     # See the {Wx::GRID::GridCellAttr} class for more information about controlling cell attributes.
     # @param row [Integer] 
@@ -2167,6 +2372,7 @@ module Wx::GRID
     def set_attr(row, col, attr) end
     
     # Sets the cell attributes for all cells in the specified column.
+    # 
     # For more information about controlling grid cell attributes see the {Wx::GRID::GridCellAttr} cell attribute class and the wxGrid Overview.
     # @param col [Integer] 
     # @param attr [Wx::GRID::GridCellAttr] 
@@ -2174,6 +2380,7 @@ module Wx::GRID
     def set_col_attr(col, attr) end
     
     # Sets the extra margins used around the grid area.
+    # 
     # A grid may occupy more space than needed for its data display and this function allows setting how big this extra space is
     # @param extraWidth [Integer] 
     # @param extraHeight [Integer] 
@@ -2181,6 +2388,7 @@ module Wx::GRID
     def set_margins(extraWidth, extraHeight) end
     
     # Sets the cell attributes for all cells in the specified row.
+    # 
     # The grid takes ownership of the attribute pointer.
     # See the {Wx::GRID::GridCellAttr} class for more information about controlling cell attributes.
     # @param row [Integer] 
@@ -2189,6 +2397,7 @@ module Wx::GRID
     def set_row_attr(row, attr) end
     
     # Appends one or more new columns to the right of the grid.
+    # 
     # The updateLabels argument is not used at present. If you are using a derived grid table class you will need to override {Wx::GRID::GridTableBase#append_cols}. See {Wx::GRID::Grid#insert_cols} for further information.
     # true on success or false if appending columns failed.
     # @param reg [Wx::Region] 
@@ -2197,6 +2406,7 @@ module Wx::GRID
     def calc_row_labels_exposed(reg, gridWindow=nil) end
     
     # Appends one or more new columns to the right of the grid.
+    # 
     # The updateLabels argument is not used at present. If you are using a derived grid table class you will need to override {Wx::GRID::GridTableBase#append_cols}. See {Wx::GRID::Grid#insert_cols} for further information.
     # true on success or false if appending columns failed.
     # @param reg [Wx::Region] 
@@ -2205,6 +2415,7 @@ module Wx::GRID
     def calc_col_labels_exposed(reg, gridWindow=nil) end
     
     # Appends one or more new columns to the right of the grid.
+    # 
     # The updateLabels argument is not used at present. If you are using a derived grid table class you will need to override {Wx::GRID::GridTableBase#append_cols}. See {Wx::GRID::Grid#insert_cols} for further information.
     # true on success or false if appending columns failed.
     # @param reg [Wx::Region] 
@@ -2213,6 +2424,7 @@ module Wx::GRID
     def calc_cells_exposed(reg, gridWindow=nil) end
     
     # Return the column in which the sorting indicator is currently displayed.
+    # 
     # Returns {Wx::NOT_FOUND} if sorting indicator is not currently displayed at all.
     # @see Wx::GRID::Grid#set_sorting_column 
     # @return [Integer]
@@ -2221,6 +2433,7 @@ module Wx::GRID
     
     # Return true if this column is currently used for sorting.
     # 
+    # 
     # @see Wx::GRID::Grid#get_sorting_column 
     # @param col [Integer] 
     # @return [Boolean]
@@ -2228,6 +2441,7 @@ module Wx::GRID
     alias_method :sorting_by?, :is_sorting_by
     
     # Return true if the current sorting order is ascending or false if it is descending.
+    # 
     # It only makes sense to call this function if {Wx::GRID::Grid#get_sorting_column} returns a valid column index and not {Wx::NOT_FOUND}.
     # @see Wx::GRID::Grid#set_sorting_column 
     # @return [Boolean]
@@ -2236,6 +2450,7 @@ module Wx::GRID
     
     # Set the column to display the sorting indicator in and its direction.
     # 
+    # 
     # @see Wx::GRID::Grid#get_sorting_column
     # @see  Wx::GRID::Grid#is_sort_order_ascending 
     # @param col [Integer]  The column to display the sorting indicator in or {Wx::NOT_FOUND} to remove any currently displayed sorting indicator.
@@ -2245,41 +2460,48 @@ module Wx::GRID
     alias_method :sorting_column=, :set_sorting_column
     
     # Remove any currently shown sorting indicator.
+    # 
     # This is equivalent to calling {Wx::GRID::Grid#set_sorting_column} with {Wx::NOT_FOUND} first argument.
     # @return [void]
     def unset_sorting_column; end
     
     # Return the main grid window containing the grid cells.
+    # 
     # This window is always shown.
     # @return [Wx::Window]
     def get_grid_window; end
     alias_method :grid_window, :get_grid_window
     
     # Return the corner grid window containing frozen cells.
+    # 
     # This window is shown only when there are frozen rows and columns.
     # @return [Wx::Window]
     def get_frozen_corner_grid_window; end
     alias_method :frozen_corner_grid_window, :get_frozen_corner_grid_window
     
     # Return the rows grid window containing row frozen cells.
+    # 
     # This window is shown only when there are frozen rows.
     # @return [Wx::Window]
     def get_frozen_row_grid_window; end
     alias_method :frozen_row_grid_window, :get_frozen_row_grid_window
     
     # Return the columns grid window containing column frozen cells.
+    # 
     # This window is shown only when there are frozen columns.
     # @return [Wx::Window]
     def get_frozen_col_grid_window; end
     alias_method :frozen_col_grid_window, :get_frozen_col_grid_window
     
     # Return the row labels window.
+    # 
     # This window is not shown if the row labels were hidden using {Wx::GRID::Grid#hide_row_labels}.
     # @return [Wx::Window]
     def get_grid_row_label_window; end
     alias_method :grid_row_label_window, :get_grid_row_label_window
     
     # Return the column labels window.
+    # 
     # This window is not shown if the columns labels were hidden using {Wx::GRID::Grid#hide_col_labels}.
     # Depending on whether {Wx::GRID::Grid#use_native_col_header} was called or not this can be either a {Wx::HeaderCtrl} or a plain {Wx::Window}. This function returns a valid window pointer in either case but in the former case you can also use {Wx::GRID::Grid#get_grid_col_header} to access it if you need {Wx::HeaderCtrl}-specific functionality.
     # @return [Wx::Window]
@@ -2287,12 +2509,14 @@ module Wx::GRID
     alias_method :grid_col_label_window, :get_grid_col_label_window
     
     # Return the window in the top left grid corner.
+    # 
     # This window is shown only of both columns and row labels are shown and normally doesn't contain anything. Clicking on it is handled by {Wx::GRID::Grid} however and can be used to select the entire grid.
     # @return [Wx::Window]
     def get_grid_corner_label_window; end
     alias_method :grid_corner_label_window, :get_grid_corner_label_window
     
     # Return the header control used for column labels display.
+    # 
     # This function can only be called if {Wx::GRID::Grid#use_native_col_header} had been called.
     # @see Wx::GRID::Grid#is_using_native_header 
     # @return [Wx::HeaderCtrl]
@@ -2391,14 +2615,17 @@ module Wx::GRID
   end # Grid
   
   # Represents coordinates of a block of cells in the grid.
+  # 
   # An object of this class contains coordinates of the left top and the bottom right corners of a block.
   # 
   # 
   # @note This class is <b>untracked</b> and should not be derived from nor instances extended!
+  # @wxrb_require USE_GRID
   class GridBlockCoords < ::Object
   
     # @overload initialize()
     #   Default constructor initializes the object to invalid state.
+    #   
     #   Initially the coordinates are invalid (-1) and so {Wx::GRID::GridBlockCoords#!()} for an uninitialized {Wx::GRID::GridBlockCoords} returns true.
     #   @return [Wx::GRID::GridBlockCoords]
     # @overload initialize(topRow, leftCol, bottomRow, rightCol)
@@ -2469,6 +2696,7 @@ module Wx::GRID
     def canonicalize; end
     
     # Whether the blocks intersect.
+    # 
     # true, if the block intersects with the other, false, otherwise.
     # @param other [Wx::GRID::GridBlockCoords] 
     # @return [Boolean]
@@ -2476,17 +2704,20 @@ module Wx::GRID
     
     # @overload contains(cell)
     #   Check whether this block contains the given cell.
+    #   
     #   true, if the block contains the cell, false otherwise.
     #   @param cell [Array(Integer, Integer)] 
     #   @return [Boolean]
     # @overload contains(other)
     #   Check whether this block contains another one.
+    #   
     #   true if other is entirely contained within this block.
     #   @param other [Wx::GRID::GridBlockCoords] 
     #   @return [Boolean]
     def contains(*args) end
     
     # Calculates the result blocks by subtracting the other block from this block.
+    # 
     # Up to 4 blocks. If block doesn't exist in the result, it has value of {Wx::GridNoBlockCoords}.
     # @param other [Wx::GRID::GridBlockCoords]  The block to subtract from this block.
     # @param splitOrientation [Integer]  The block splitting orientation (either {Wx::Orientation::HORIZONTAL} or {Wx::Orientation::VERTICAL}).
@@ -2494,6 +2725,7 @@ module Wx::GRID
     def difference(other, splitOrientation) end
     
     # Calculates the symmetric difference of the blocks.
+    # 
     # Up to 4 blocks. If block doesn't exist in the result, it has value of {Wx::GridNoBlockCoords}.
     # @param other [Wx::GRID::GridBlockCoords]  The block to subtract from this block.
     # @return [Wx::GRID::GridBlockDiffResult]
@@ -2507,23 +2739,26 @@ module Wx::GRID
   end # GridBlockCoords
   
   # The helper struct uses as a result type for difference functions of {Wx::GRID::GridBlockCoords} class.
+  # 
   # Parts can be uninitialized (equals to {Wx::GridNoBlockCoords}), that means that the corresponding part doesn't exists in the result.
   # 
   # 
   # @note This class is <b>untracked</b> and should not be derived from nor instances extended!
+  # @wxrb_require USE_GRID
   class GridBlockDiffResult < ::Object
   
   end # GridBlockDiffResult
   
   # {Wx::GRID::GridSizesInfo} stores information about sizes of all {Wx::GRID::Grid} rows or columns.
+  # 
   # It assumes that most of the rows or columns (which are both called elements here as the difference between them doesn't matter at this class level) have the default size and so stores it separately. And it uses a {Wx::HashMap} to store the sizes of all elements which have the non-default size.
   # This structure is particularly useful for serializing the sizes of all {Wx::GRID::Grid} elements at once.
-  # === 
   # 
   # Category:  Grid Related Classes
   # 
   # 
   # @note This class is <b>untracked</b> and should not be derived from nor instances extended!
+  # @wxrb_require USE_GRID
   class GridSizesInfo < ::Object
   
     # Default size.
@@ -2552,10 +2787,12 @@ module Wx::GRID
     
     # @overload initialize()
     #   Default constructor.
+    #   
     #   m_sizeDefault and m_customSizes must be initialized later.
     #   @return [Wx::GRID::GridSizesInfo]
     # @overload initialize(defSize, allSizes)
     #   Constructor.
+    #   
     #   This constructor is used by {Wx::GRID::Grid#get_row_sizes} and GetColSizes() methods. User code will usually use the default constructor instead.
     #   @param defSize [Integer]  The default element size.
     #   @param allSizes [Array<Integer>]  Array containing the sizes of all elements, including those which have the default size.
@@ -2563,6 +2800,7 @@ module Wx::GRID
     def initialize(*args) end
     
     # Get the element size.
+    # 
     # The size for this element, using m_customSizes if pos is in it or m_sizeDefault otherwise.
     # @param pos [unsigned]  The index of the element.
     # @return [Integer]
@@ -2572,6 +2810,7 @@ module Wx::GRID
   end # GridSizesInfo
   
   # Allows to specify the behaviour when the cell contents doesn't fit into its allotted space.
+  # 
   # Objects of this class are used with {Wx::GRID::GridCellAttr#set_fit_mode} and {Wx::GRID::Grid#set_default_cell_fit_mode} and {Wx::GRID::Grid#set_cell_fit_mode} functions and allow to specify what should happen if the cell contents doesn't fit into the available space. The possibilities are:
   # 
   # - Overflow into the cell to the right if it is empty, or possibly several cells, if the cell contents still doesn't fit after overflowing into the immediately neighbouring cell.
@@ -2584,38 +2823,43 @@ module Wx::GRID
   # ```
   # 
   # Objects of this class are created using static functions instead of constructors for better readability and can't be changed after creating them except by using the assignment operator.
-  # === 
   # 
   # Category:  Grid Related Classes
   # 
   # 
   # @note This class is <b>untracked</b> and should not be derived from nor instances extended!
+  # @wxrb_require USE_GRID
   class GridFitMode < ::Object
   
     # Default constructor creates an object not specifying any behaviour.
+    # 
     # This constructor is not very useful, use static methods {Wx::GRID::GridFitMode.clip} and {Wx::GRID::GridFitMode.overflow} below to create objects of this class instead.
     # @return [Wx::GRID::GridFitMode]
     def initialize; end
     
     # Return true if the object specifies some particular behaviour.
+    # 
     # This method returns false for default-constructed objects of this type only.
     # @return [Boolean]
     def is_specified; end
     alias_method :specified?, :is_specified
     
     # Return true if the object specifies clipping behaviour.
+    # 
     # This method returns true only for the objects returned by {Wx::GRID::GridFitMode.clip}.
     # @return [Boolean]
     def is_clip; end
     alias_method :clip?, :is_clip
     
     # Return true if the object specifies overflow behaviour.
+    # 
     # This method returns true only for the objects returned by {Wx::GRID::GridFitMode.overflow}.
     # @return [Boolean]
     def is_overflow; end
     alias_method :overflow?, :is_overflow
     
     # Return ellipsize mode, possibly {Wx::EllipsizeMode::ELLIPSIZE_NONE}.
+    # 
     # For the objects constructed using {Wx::GRID::GridFitMode.ellipsize}, the same ellipsization mode as was passed to it is returned. For all the other objects, {Wx::EllipsizeMode::ELLIPSIZE_NONE} is.
     # @return [Wx::EllipsizeMode]
     def get_ellipsize_mode; end