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

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

@@ -206,12 +206,22 @@ module Wx::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:
   # 
-  # - {Wx::GRID::GridCellBoolRenderer}- {Wx::GRID::GridCellFloatRenderer}- {Wx::GRID::GridCellNumberRenderer}- {Wx::GRID::GridCellStringRenderer}- {Wx::GRID::GridCellDateRenderer}- {Wx::GRID::GridCellDateTimeRenderer}
+  # - {Wx::GRID::GridCellBoolRenderer}
+  # - {Wx::GRID::GridCellFloatRenderer}
+  # - {Wx::GRID::GridCellNumberRenderer}
+  # - {Wx::GRID::GridCellStringRenderer}
+  # - {Wx::GRID::GridCellDateRenderer}
+  # - {Wx::GRID::GridCellDateTimeRenderer}
   # 
   # The look of a cell can be further defined using {Wx::GRID::GridCellAttr}. An object of this type may be returned by {Wx::GRID::GridTableBase#get_attr}.
   # {Wx::GRID::GridCellEditor} is the abstract base class for editing the value of a cell. The following editors are predefined:
   # 
-  # - {Wx::GRID::GridCellBoolEditor}- {Wx::GRID::GridCellChoiceEditor}- {Wx::GRID::GridCellFloatEditor}- {Wx::GRID::GridCellNumberEditor}- {Wx::GRID::GridCellTextEditor}- {Wx::GRID::GridCellDateEditor}
+  # - {Wx::GRID::GridCellBoolEditor}
+  # - {Wx::GRID::GridCellChoiceEditor}
+  # - {Wx::GRID::GridCellFloatEditor}
+  # - {Wx::GRID::GridCellNumberEditor}
+  # - {Wx::GRID::GridCellTextEditor}
+  # - {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}.
   # === 
@@ -297,7 +307,7 @@ 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 [Grid]
+    #   @return [Wx::GRID::Grid]
     # @overload initialize(parent, id, pos=Wx::DEFAULT_POSITION, size=Wx::DEFAULT_SIZE, style=Wx::WANTS_CHARS, name=Wx::GridNameStr)
     #   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.
@@ -307,7 +317,7 @@ module Wx::GRID
     #   @param size [Array(Integer, Integer), Wx::Size] 
     #   @param style [Integer] 
     #   @param name [String] 
-    #   @return [Grid]
+    #   @return [Wx::GRID::Grid]
     def initialize(*args) end
     
     # Creates the grid window for an object initialized using the default constructor.
@@ -318,7 +328,7 @@ module Wx::GRID
     # @param size [Array(Integer, Integer), Wx::Size] 
     # @param style [Integer] 
     # @param name [String] 
-    # @return [true,false]
+    # @return [Boolean]
     def create(parent, id, pos=Wx::DEFAULT_POSITION, size=Wx::DEFAULT_SIZE, style=Wx::WANTS_CHARS, name=Wx::GridNameStr) end
     
     # Creates a grid with the specified initial number of rows and columns.
@@ -326,25 +336,25 @@ module Wx::GRID
     # 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 [GridSelectionModes] 
-    # @return [true,false]
+    # @param selmode [Wx::wxGrid::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::GridTableBase]  The heap-allocated pointer to the table.
-    # @param selmode [GridSelectionModes]  Selection mode to use.
+    # @param table [Wx::GRID::GridTableBase]  The heap-allocated pointer to the table.
+    # @param selmode [Wx::wxGrid::GridSelectionModes]  Selection mode to use.
     # @return [void]
     def assign_table(table, selmode=Wx::GRID::Grid::GridSelectionModes::GridSelectCells) end
     
     # Receive and handle a message from the table.
-    # @param msg [Wx::GridTableMessage] 
-    # @return [true,false]
+    # @param msg [Wx::GRID::GridTableMessage] 
+    # @return [Boolean]
     def process_table_message(msg) end
     
     # Turns the drawing of grid lines on or off.
-    # @param enable [true,false] 
+    # @param enable [Boolean] 
     # @return [void]
     def enable_grid_lines(enable=true) end
     
@@ -374,16 +384,22 @@ module Wx::GRID
     # 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: 
-    # ```
-    #   // in a grid displaying music notation, use a solid black pen between
-    #   // octaves (C0=row 127, C1=row 115 etc.)
-    #   wxPen MidiGrid::GetRowGridLinePen(int row)
-    #   {
-    #       if ( row % 12 == 7 )
-    #           return wxPen(*wxBLACK, 1, wxPENSTYLE_SOLID);
+    # ```ruby
+    #   class MidiGrid < Wx::GRID::Grid
+    # 
+    #     # ...
+    # 
+    #     # in a grid displaying music notation, use a solid black pen between
+    #     # octaves (C0=row 127, C1=row 115 etc.)
+    #     def get_row_grid_line_pen(row)
+    #       if row % 12 == 7 
+    #         Wx::Pen.new(Wx::BLACK, 1, Wx::PENSTYLE_SOLID)
     #       else
-    #           return GetDefaultGridLinePen();
-    #   }
+    #         get_default_grid_line_pen
+    #       end
+    #     end
+    # 
+    #   end
     # ```
     # @param row [Integer] 
     # @return [Wx::Pen]
@@ -391,7 +407,7 @@ module Wx::GRID
     alias_method :row_grid_line_pen, :get_row_grid_line_pen
     
     # Returns true if drawing of grid lines is turned on, false otherwise.
-    # @return [true,false]
+    # @return [Boolean]
     def grid_lines_enabled; end
     
     # Sets the colour used to draw grid lines.
@@ -553,7 +569,7 @@ module Wx::GRID
     # 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 [true,false] 
+    # @param native [Boolean] 
     # @return [void]
     def set_use_native_col_labels(native=true) end
     alias_method :use_native_col_labels=, :set_use_native_col_labels
@@ -563,8 +579,8 @@ module Wx::GRID
     # 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).
     # Finally, please note that using the native control is currently incompatible with freezing columns in the grid (see {Wx::GRID::Grid#freeze_to}) and this function will return false, without doing anything, if it's called on a grid in which any columns are frozen.
-    # @param native [true,false] 
-    # @return [true,false]
+    # @param native [Boolean] 
+    # @return [Boolean]
     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.
@@ -679,7 +695,7 @@ module Wx::GRID
     
     # 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 [true,false]
+    # @return [Boolean]
     def can_enable_cell_control; end
     alias_method :can_enable_cell_control?, :can_enable_cell_control
     
@@ -692,14 +708,14 @@ module Wx::GRID
     # 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.
-    # @param enable [true,false] 
+    # @param enable [Boolean] 
     # @return [void]
     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 [true,false] 
+    # @param edit [Boolean] 
     # @return [void]
     def enable_editing(edit) end
     
@@ -783,14 +799,14 @@ module Wx::GRID
     def hide_cell_edit_control; end
     
     # Returns true if the in-place edit control is currently enabled.
-    # @return [true,false]
+    # @return [Boolean]
     def is_cell_edit_control_enabled; end
     alias_method :cell_edit_control_enabled?, :is_cell_edit_control_enabled
     
     # Returns true if the in-place edit control is currently shown.
     # 
     # @see Wx::GRID::Grid#hide_cell_edit_control 
-    # @return [true,false]
+    # @return [Boolean]
     def is_cell_edit_control_shown; end
     alias_method :cell_edit_control_shown?, :is_cell_edit_control_shown
     
@@ -798,13 +814,13 @@ module Wx::GRID
     # 
     # @see Wx::GRID::Grid#set_read_only
     # @see  Wx::GRID::Grid#is_read_only 
-    # @return [true,false]
+    # @return [Boolean]
     def is_current_cell_read_only; end
     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 [true,false]
+    # @return [Boolean]
     def is_editable; end
     alias_method :editable?, :is_editable
     
@@ -814,7 +830,7 @@ module Wx::GRID
     # @see  Wx::GRID::Grid#is_current_cell_read_only 
     # @param row [Integer] 
     # @param col [Integer] 
-    # @return [true,false]
+    # @return [Boolean]
     def is_read_only(row, col) end
     alias_method :read_only?, :is_read_only
     
@@ -823,8 +839,8 @@ module Wx::GRID
     # 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.
     # @param typeName [String]  Name of the new type. May be any string, but if the type name is the same as the name of an already registered type, including one of the standard ones (which are {Wx::GRID::GRID_VALUE_STRING}, {Wx::GRID::GRID_VALUE_BOOL}, {Wx::GRID::GRID_VALUE_NUMBER}, {Wx::GRID::GRID_VALUE_FLOAT}, {Wx::GRID::GRID_VALUE_CHOICE} and {Wx::GRID::GRID_VALUE_DATE}), then the new registration information replaces the previously used renderer and editor.
-    # @param renderer [Wx::GridCellRenderer]  The renderer to use for the cells of this type. Its ownership is taken by the grid, i.e. it will call DecRef() on this pointer when it doesn't need it any longer.
-    # @param editor [Wx::GridCellEditor]  The editor to use for the cells of this type. Its ownership is also taken by the grid.
+    # @param renderer [Wx::GRID::GridCellRenderer]  The renderer to use for the cells of this type. Its ownership is taken by the grid, i.e. it will call DecRef() on this pointer when it doesn't need it any longer.
+    # @param editor [Wx::GRID::GridCellEditor]  The editor to use for the cells of this type. Its ownership is also taken by the grid.
     # @return [void]
     def register_data_type(typeName, renderer, editor) end
     
@@ -838,7 +854,7 @@ module Wx::GRID
     # See {Wx::GRID::GridCellEditor} and the wxGrid Overview for more information about cell editors and renderers.
     # @param row [Integer] 
     # @param col [Integer] 
-    # @param editor [Wx::GridCellEditor] 
+    # @param editor [Wx::GRID::GridCellEditor] 
     # @return [void]
     def set_cell_editor(row, col, editor) end
     
@@ -847,7 +863,7 @@ module Wx::GRID
     # See {Wx::GRID::GridCellRenderer} and the wxGrid Overview for more information about cell editors and renderers.
     # @param row [Integer] 
     # @param col [Integer] 
-    # @param renderer [Wx::GridCellRenderer] 
+    # @param renderer [Wx::GRID::GridCellRenderer] 
     # @return [void]
     def set_cell_renderer(row, col, renderer) end
     
@@ -906,7 +922,7 @@ module Wx::GRID
     # 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::GridCellEditor] 
+    # @param editor [Wx::GRID::GridCellEditor] 
     # @return [void]
     def set_default_editor(editor) end
     alias_method :default_editor=, :set_default_editor
@@ -914,7 +930,7 @@ module Wx::GRID
     # 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::GridCellRenderer] 
+    # @param renderer [Wx::GRID::GridCellRenderer] 
     # @return [void]
     def set_default_renderer(renderer) end
     alias_method :default_renderer=, :set_default_renderer
@@ -924,7 +940,7 @@ module Wx::GRID
     # @see Wx::GRID::Grid#is_read_only 
     # @param row [Integer] 
     # @param col [Integer] 
-    # @param isReadOnly [true,false] 
+    # @param isReadOnly [Boolean] 
     # @return [void]
     def set_read_only(row, col, isReadOnly=true) end
     
@@ -945,20 +961,20 @@ module Wx::GRID
     # 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 [true,false] 
+    # @param setAsMin [Boolean] 
     # @return [void]
     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 [true,false] 
+    # @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 [true,false] 
+    # @param setAsMin [Boolean] 
     # @return [void]
     def auto_size_row(row, setAsMin=true) end
     
@@ -969,25 +985,25 @@ module Wx::GRID
     
     # 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 [true,false] 
+    # @param setAsMin [Boolean] 
     # @return [void]
     def auto_size_rows(setAsMin=true) end
     
     # Returns the cell fitting mode.
     # 
-    # @see Wx::GridFitMode
+    # @see Wx::GRID::GridFitMode
     # @param row [Integer] 
     # @param col [Integer] 
-    # @return [Wx::GridFitMode]
+    # @return [Wx::GRID::GridFitMode]
     def get_cell_fit_mode(row, col) end
     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::GridFitMode#is_overflow on the returned value.
+    # 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] 
     # @param col [Integer] 
-    # @return [true,false]
+    # @return [Boolean]
     def get_cell_overflow(row, col) end
     alias_method :cell_overflow, :get_cell_overflow
     
@@ -1011,21 +1027,21 @@ module Wx::GRID
     
     # Returns true if the specified column is not currently hidden.
     # @param col [Integer] 
-    # @return [true,false]
+    # @return [Boolean]
     def is_col_shown(col) end
     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::GridFitMode
-    # @return [Wx::GridFitMode]
+    # @see Wx::GRID::GridFitMode
+    # @return [Wx::GRID::GridFitMode]
     def get_default_cell_fit_mode; end
     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::GridFitMode#is_overflow on the returned value.
+    # 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 [true,false]
+    # @return [Boolean]
     def get_default_cell_overflow; end
     alias_method :default_cell_overflow, :get_default_cell_overflow
     
@@ -1069,16 +1085,16 @@ module Wx::GRID
     
     # Returns true if the specified row is not currently hidden.
     # @param row [Integer] 
-    # @return [true,false]
+    # @return [Boolean]
     def is_row_shown(row) end
     alias_method :row_shown?, :is_row_shown
     
     # Specifies the behaviour of the cell contents if it doesn't fit into the available space.
     # 
-    # @see Wx::GridFitMode
+    # @see Wx::GRID::GridFitMode
     # @param row [Integer] 
     # @param col [Integer] 
-    # @param fitMode [Wx::GridFitMode] 
+    # @param fitMode [Wx::GRID::GridFitMode] 
     # @return [void]
     def set_cell_fit_mode(row, col, fitMode) end
     
@@ -1086,7 +1102,7 @@ module Wx::GRID
     # Prefer using {Wx::GRID::Grid#set_cell_fit_mode} in the new code.
     # @param row [Integer] 
     # @param col [Integer] 
-    # @param allow [true,false] 
+    # @param allow [Boolean] 
     # @return [void]
     def set_cell_overflow(row, col, allow) end
     
@@ -1137,15 +1153,15 @@ module Wx::GRID
     
     # Specifies the default behaviour of the cell contents if it doesn't fit into the available space.
     # 
-    # @see Wx::GridFitMode
-    # @param fitMode [Wx::GridFitMode] 
+    # @see Wx::GRID::GridFitMode
+    # @param fitMode [Wx::GRID::GridFitMode] 
     # @return [void]
     def set_default_cell_fit_mode(fitMode) end
     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 [true,false] 
+    # @param allow [Boolean] 
     # @return [void]
     def set_default_cell_overflow(allow) end
     alias_method :default_cell_overflow=, :set_default_cell_overflow
@@ -1154,7 +1170,7 @@ module Wx::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] 
-    # @param resizeExistingCols [true,false] 
+    # @param resizeExistingCols [Boolean] 
     # @return [void]
     def set_default_col_size(width, resizeExistingCols=false) end
     alias_method :default_col_size=, :set_default_col_size
@@ -1163,7 +1179,7 @@ module Wx::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] 
-    # @param resizeExistingRows [true,false] 
+    # @param resizeExistingRows [Boolean] 
     # @return [void]
     def set_default_row_size(height, resizeExistingRows=false) end
     alias_method :default_row_size=, :set_default_row_size
@@ -1214,24 +1230,24 @@ module Wx::GRID
     
     # 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::GridSizesInfo
+    # @see Wx::GRID::GridSizesInfo
     # @see  Wx::GRID::Grid#get_row_sizes 
-    # @return [Wx::GridSizesInfo]
+    # @return [Wx::GRID::GridSizesInfo]
     def get_col_sizes; end
     alias_method :col_sizes, :get_col_sizes
     
     # Get size information for all row at once.
     # 
-    # @see Wx::GridSizesInfo
+    # @see Wx::GRID::GridSizesInfo
     # @see  Wx::GRID::Grid#get_col_sizes 
-    # @return [Wx::GridSizesInfo]
+    # @return [Wx::GRID::GridSizesInfo]
     def get_row_sizes; end
     alias_method :row_sizes, :get_row_sizes
     
     # Restore all columns sizes.
-    # This is usually called with {Wx::GridSizesInfo} object previously returned by {Wx::GRID::Grid#get_col_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::GridSizesInfo] 
+    # @param sizeInfo [Wx::GRID::GridSizesInfo] 
     # @return [void]
     def set_col_sizes(sizeInfo) end
     alias_method :col_sizes=, :set_col_sizes
@@ -1239,7 +1255,7 @@ module Wx::GRID
     # Restore all rows sizes.
     # 
     # @see Wx::GRID::Grid#set_col_sizes 
-    # @param sizeInfo [Wx::GridSizesInfo] 
+    # @param sizeInfo [Wx::GRID::GridSizesInfo] 
     # @return [void]
     def set_row_sizes(sizeInfo) end
     alias_method :row_sizes=, :set_row_sizes
@@ -1273,30 +1289,30 @@ 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(CellSpan,Integer,Integer)]
+    #   @return [Array(Wx::wxGrid::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 [Wx::GridCellCoords] 
+    #   @param coords [Array(Integer, Integer)] 
     #   @return [Wx::Size]
     def get_cell_size(*args) end
     alias_method :cell_size, :get_cell_size
     
     # Return true if the dragging of cells is enabled or false otherwise.
-    # @return [true,false]
+    # @return [Boolean]
     def can_drag_cell; end
     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 [true,false]
+    # @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 [true,false]
+    # @return [Boolean]
     def can_drag_col_size(col) end
     alias_method :can_drag_col_size?, :can_drag_col_size
     
@@ -1304,7 +1320,7 @@ module Wx::GRID
     # 
     # @see Wx::GRID::Grid#can_drag_grid_size
     # @see  Wx::GRID::Grid#can_drag_col_size
-    # @return [true,false]
+    # @return [Boolean]
     def can_drag_grid_col_edges; end
     alias_method :can_drag_grid_col_edges?, :can_drag_grid_col_edges
     
@@ -1312,30 +1328,30 @@ module Wx::GRID
     # 
     # @see Wx::GRID::Grid#can_drag_grid_size
     # @see  Wx::GRID::Grid#can_drag_row_size
-    # @return [true,false]
+    # @return [Boolean]
     def can_drag_grid_row_edges; end
     alias_method :can_drag_grid_row_edges?, :can_drag_grid_row_edges
     
     # Return true if the dragging of grid lines to resize rows and columns is enabled or false otherwise.
-    # @return [true,false]
+    # @return [Boolean]
     def can_drag_grid_size; end
     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 [true,false]
+    # @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 [true,false]
+    # @return [Boolean]
     def can_drag_row_size(row) end
     alias_method :can_drag_row_size?, :can_drag_row_size
     
     # Returns true if columns can be hidden from the popup menu of the native header.
-    # @return [true,false]
+    # @return [Boolean]
     def can_hide_columns; end
     alias_method :can_hide_columns?, :can_hide_columns
     
@@ -1386,38 +1402,38 @@ module Wx::GRID
     def disable_hiding_columns; end
     
     # Enables or disables cell dragging with the mouse.
-    # @param enable [true,false] 
+    # @param enable [Boolean] 
     # @return [void]
     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 [true,false] 
-    # @return [true,false]
+    # @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 [true,false] 
-    # @return [true,false]
+    # @param enable [Boolean] 
+    # @return [Boolean]
     def enable_drag_row_move(enable=true) end
     
     # Enables or disables column sizing by dragging with the mouse.
     # 
     # @see Wx::GRID::Grid#disable_col_resize 
-    # @param enable [true,false] 
+    # @param enable [Boolean] 
     # @return [void]
     def enable_drag_col_size(enable=true) end
     
     # Enables or disables row and column resizing by dragging gridlines with the mouse.
-    # @param enable [true,false] 
+    # @param enable [Boolean] 
     # @return [void]
     def enable_drag_grid_size(enable=true) end
     
     # Enables or disables row sizing by dragging with the mouse.
     # 
     # @see Wx::GRID::Grid#disable_row_resize 
-    # @param enable [true,false] 
+    # @param enable [Boolean] 
     # @return [void]
     def enable_drag_row_size(enable=true) end
     
@@ -1426,8 +1442,8 @@ module Wx::GRID
     # 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.
     # @see Wx::GRID::Grid#disable_hiding_columns 
-    # @param enable [true,false] 
-    # @return [true,false]
+    # @param enable [Boolean] 
+    # @return [Boolean]
     def enable_hiding_columns(enable=true) end
     
     # Returns the column ID of the specified column position.
@@ -1449,7 +1465,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.
+    # 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]
     def set_columns_order(order) end
@@ -1490,7 +1506,7 @@ module Wx::GRID
     
     # 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 [Wx::GridCellCoords]
+    # @return [Array(Integer, Integer)]
     def get_grid_cursor_coords; end
     alias_method :grid_cursor_coords, :get_grid_cursor_coords
     
@@ -1517,64 +1533,64 @@ module Wx::GRID
     # @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 [Wx::GridCellCoords] 
+    #   @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 [true,false] 
-    # @return [true,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 [true,false] 
-    # @return [true,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 [true,false] 
-    # @return [true,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 [true,false] 
-    # @return [true,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 [true,false] 
-    # @return [true,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 [true,false] 
-    # @return [true,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 [true,false] 
-    # @return [true,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 [true,false] 
-    # @return [true,false]
+    # @param expandSelection [Boolean] 
+    # @return [Boolean]
     def move_cursor_up_block(expandSelection) end
     
     # Moves the grid cursor down by some number of rows so that the previous bottom visible row becomes the top visible row.
-    # @return [true,false]
+    # @return [Boolean]
     def move_page_down; end
     
     # Moves the grid cursor up by some number of rows so that the previous top visible row becomes the bottom visible row.
-    # @return [true,false]
+    # @return [Boolean]
     def move_page_up; end
     
     # @overload set_grid_cursor(row, col)
@@ -1590,7 +1606,7 @@ module Wx::GRID
     #   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.
-    #   @param coords [Wx::GridCellCoords] 
+    #   @param coords [Array(Integer, Integer)] 
     #   @return [void]
     def set_grid_cursor(*args) end
     alias_method :grid_cursor=, :set_grid_cursor
@@ -1599,7 +1615,7 @@ module Wx::GRID
     # 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 [TabBehaviour] 
+    # @param behaviour [Wx::wxGrid::TabBehaviour] 
     # @return [void]
     def set_tab_behaviour(behaviour) end
     alias_method :tab_behaviour=, :set_tab_behaviour
@@ -1630,14 +1646,14 @@ module Wx::GRID
     # 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 [Wx::GridBlockCoordsVector]
+    # @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 [Wx::GridBlockCoordsVector]
+    # @return [Array<Wx::GRID::GridBlockCoords]
     def get_selected_col_blocks; end
     alias_method :selected_col_blocks, :get_selected_col_blocks
     
@@ -1692,19 +1708,19 @@ module Wx::GRID
     # Returns the current selection mode.
     # 
     # @see Wx::GRID::Grid#set_selection_mode. 
-    # @return [GridSelectionModes]
+    # @return [Wx::wxGrid::GridSelectionModes]
     def get_selection_mode; end
     alias_method :selection_mode, :get_selection_mode
     
     # Returns true if the given cell is selected.
     # @param row [Integer] 
     # @param col [Integer] 
-    # @return [true,false]
+    # @return [Boolean]
     def is_in_selection(row, col) end
     alias_method :in_selection?, :is_in_selection
     
     # Returns true if there are currently any selected cells, rows, columns or blocks.
-    # @return [true,false]
+    # @return [Boolean]
     def is_selection; end
     alias_method :selection?, :is_selection
     
@@ -1718,7 +1734,7 @@ module Wx::GRID
     # @param leftCol [Integer] 
     # @param bottomRow [Integer] 
     # @param rightCol [Integer] 
-    # @param addToSelected [true,false] 
+    # @param addToSelected [Boolean] 
     # @return [void]
     def select_block(topRow, leftCol, bottomRow, rightCol, addToSelected=false) end
     
@@ -1726,7 +1742,7 @@ module Wx::GRID
     # 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] 
-    # @param addToSelected [true,false] 
+    # @param addToSelected [Boolean] 
     # @return [void]
     def select_col(col, addToSelected=false) end
     
@@ -1734,7 +1750,7 @@ module Wx::GRID
     # 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] 
-    # @param addToSelected [true,false] 
+    # @param addToSelected [Boolean] 
     # @return [void]
     def select_row(row, addToSelected=false) end
     
@@ -1752,7 +1768,7 @@ module Wx::GRID
     
     # 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 [GridSelectionModes] 
+    # @param selmode [Wx::wxGrid::GridSelectionModes] 
     # @return [void]
     def set_selection_mode(selmode) end
     alias_method :selection_mode=, :set_selection_mode
@@ -1779,8 +1795,8 @@ module Wx::GRID
     # 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] 
-    # @param wholeCellVisible [true,false] 
-    # @return [true,false]
+    # @param wholeCellVisible [Boolean] 
+    # @return [Boolean]
     def is_visible(row, col, wholeCellVisible=true) end
     alias_method :visible?, :is_visible
     
@@ -1826,9 +1842,9 @@ module Wx::GRID
     # 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 [Wx::GridCellCoords] 
-    # @param bottomRight [Wx::GridCellCoords] 
-    # @param gridWindow [Wx::GridWindow] 
+    # @param topLeft [Array(Integer, Integer)] 
+    # @param bottomRight [Array(Integer, Integer)] 
+    # @param gridWindow [Wx::GRID::GridWindow] 
     # @return [Wx::Rect]
     def block_to_device_rect(topLeft, bottomRight, gridWindow=nil) end
     
@@ -1845,56 +1861,47 @@ module Wx::GRID
     #   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] 
-    #   @return [Wx::GridWindow]
+    #   @return [Wx::GRID::GridWindow]
     # @overload cell_to_grid_window(coords)
     #   This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
-    #   @param coords [Wx::GridCellCoords] 
-    #   @return [Wx::GridWindow]
+    #   @param coords [Array(Integer, Integer)] 
+    #   @return [Wx::GRID::GridWindow]
     def cell_to_grid_window(*args) end
     
     # @overload device_pos_to_grid_window(pos)
     #   Returns the grid window that includes the input coordinates.
     #   @param pos [Wx::Point] 
-    #   @return [Wx::GridWindow]
+    #   @return [Wx::GRID::GridWindow]
     # @overload device_pos_to_grid_window(x, y)
     #   This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
     #   @param x [Integer] 
     #   @param y [Integer] 
-    #   @return [Wx::GridWindow]
+    #   @return [Wx::GRID::GridWindow]
     def device_pos_to_grid_window(*args) end
     
-    # @overload get_grid_window_offset(gridWindow, x, y)
-    #   Returns the grid window's offset from the grid starting position taking into account the frozen cells.
-    #   If there are no frozen cells, returns (0, 0).
-    #   @see Wx::GRID::Grid#freeze_to 
-    #   @param gridWindow [Wx::GridWindow] 
-    #   @param x [int] 
-    #   @param y [int] 
-    #   @return [void]
-    # @overload get_grid_window_offset(gridWindow)
-    #   This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
-    #   @param gridWindow [Wx::GridWindow] 
-    #   @return [Wx::Point]
-    def get_grid_window_offset(*args) end
+    # This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
+    # @param gridWindow [Wx::GRID::GridWindow] 
+    # @return [Wx::Point]
+    def get_grid_window_offset(gridWindow) end
     alias_method :grid_window_offset, :get_grid_window_offset
     
     # This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
     # @param pt [Array(Integer, Integer), Wx::Point] 
-    # @param gridWindow [Wx::GridWindow] 
+    # @param gridWindow [Wx::GRID::GridWindow] 
     # @return [Wx::Point]
     def calc_grid_window_unscrolled_position(pt, gridWindow) end
     
     # This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
     # @param pt [Array(Integer, Integer), Wx::Point] 
-    # @param gridWindow [Wx::GridWindow] 
+    # @param gridWindow [Wx::GRID::GridWindow] 
     # @return [Wx::Point]
     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 [true,false]  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.
-    # @param gridWindow [Wx::GridWindow]  The associated grid window that limits the search (note that this parameter is only available since wxWidgets 3.1.3). If gridWindow is NULL, it will consider all the cells, no matter which grid they belong to.
+    # @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.
+    # @param gridWindow [Wx::GRID::GridWindow]  The associated grid window that limits the search (note that this parameter is only available since wxWidgets 3.1.3). If gridWindow is NULL, it will consider all the cells, no matter which grid they belong to.
     # @return [Integer]
     def x_to_col(x, clipToMinMax=false, gridWindow=nil) end
     
@@ -1913,12 +1920,12 @@ module Wx::GRID
     #   @see  Wx::GRID::Grid#y_to_row 
     #   @param x [Integer] 
     #   @param y [Integer] 
-    #   @param gridWindow [Wx::GridWindow] 
+    #   @param gridWindow [Wx::GRID::GridWindow] 
     #   @return [Array(Integer, Integer)]
     # @overload xy_to_cell(pos, gridWindow=nil)
     #   This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
     #   @param pos [Array(Integer, Integer), Wx::Point] 
-    #   @param gridWindow [Wx::GridWindow] 
+    #   @param gridWindow [Wx::GRID::GridWindow] 
     #   @return [Array(Integer, Integer)]
     def xy_to_cell(*args) end
     
@@ -1932,8 +1939,8 @@ module Wx::GRID
     # 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] 
-    # @param clipToMinMax [true,false] 
-    # @param gridWindow [Wx::GridWindow] 
+    # @param clipToMinMax [Boolean] 
+    # @param gridWindow [Wx::GRID::GridWindow] 
     # @return [Integer]
     def y_to_row(y, clipToMinMax=false, gridWindow=nil) end
     
@@ -1941,30 +1948,30 @@ module Wx::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] 
-    # @param updateLabels [true,false] 
-    # @return [true,false]
+    # @param updateLabels [Boolean] 
+    # @return [Boolean]
     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] 
-    # @param updateLabels [true,false] 
-    # @return [true,false]
+    # @param updateLabels [Boolean] 
+    # @return [Boolean]
     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 
-    # @return [true,false]
+    # @return [Boolean]
     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 
-    # @return [true,false]
+    # @return [Boolean]
     def are_vert_grid_lines_clipped; end
     
     # Increments the grid's batch count.
@@ -1982,7 +1989,7 @@ module Wx::GRID
     # 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 
-    # @param clip [true,false] 
+    # @param clip [Boolean] 
     # @return [void]
     def clip_horz_grid_lines(clip) end
     
@@ -1990,7 +1997,7 @@ module Wx::GRID
     # 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 
-    # @param clip [true,false] 
+    # @param clip [Boolean] 
     # @return [void]
     def clip_vert_grid_lines(clip) end
     
@@ -1999,8 +2006,8 @@ module Wx::GRID
     # true on success or false if deleting columns failed.
     # @param pos [Integer] 
     # @param numCols [Integer] 
-    # @param updateLabels [true,false] 
-    # @return [true,false]
+    # @param updateLabels [Boolean] 
+    # @return [Boolean]
     def delete_cols(pos=0, numCols=1, updateLabels=true) end
     
     # Deletes one or more rows from a grid starting at the specified position.
@@ -2008,8 +2015,8 @@ module Wx::GRID
     # true on success or false if deleting rows failed.
     # @param pos [Integer] 
     # @param numRows [Integer] 
-    # @param updateLabels [true,false] 
-    # @return [true,false]
+    # @param updateLabels [Boolean] 
+    # @return [Boolean]
     def delete_rows(pos=0, numRows=1, updateLabels=true) end
     
     # @overload freeze_to(row, col)
@@ -2017,16 +2024,20 @@ module Wx::GRID
     #   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:
-    #   - Either row or col are out of range- Size of the frozen area would be bigger than the current viewing area- There are any merged cells in the area to be frozen- Grid uses a native header control (see {Wx::GRID::Grid#use_native_col_header})
+    #   
+    #   - Either row or col are out of range
+    #   - Size of the frozen area would be bigger than the current viewing area
+    #   - There are any merged cells in the area to be frozen
+    #   - Grid uses a native header control (see {Wx::GRID::Grid#use_native_col_header})
     #   
     #   (some of these limitations could be lifted in the future).
     #   @param row [unsigned]  The number of rows to freeze, 0 means to unfreeze all rows.
     #   @param col [unsigned]  The number of columns to freeze, 0 means to unfreeze all columns.
-    #   @return [true,false]
+    #   @return [Boolean]
     # @overload freeze_to(coords)
     #   This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
-    #   @param coords [Wx::GridCellCoords] 
-    #   @return [true,false]
+    #   @param coords [Array(Integer, Integer)] 
+    #   @return [Boolean]
     def freeze_to(*args) end
     
     # Decrements the grid's batch count.
@@ -2088,7 +2099,7 @@ module Wx::GRID
     
     # Returns a base pointer to the current table object.
     # The returned pointer is still owned by the grid.
-    # @return [Wx::GridTableBase]
+    # @return [Wx::GRID::GridTableBase]
     def get_table; end
     alias_method :table, :get_table
     
@@ -2098,8 +2109,8 @@ module Wx::GRID
     # true if the columns were successfully inserted, false if an error occurred (most likely the table couldn't be updated).
     # @param pos [Integer]  The position which the first newly inserted column will have.
     # @param numCols [Integer]  The number of columns to insert.
-    # @param updateLabels [true,false]  Currently not used.
-    # @return [true,false]
+    # @param updateLabels [Boolean]  Currently not used.
+    # @return [Boolean]
     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.
@@ -2108,8 +2119,8 @@ module Wx::GRID
     # true if the rows were successfully inserted, false if an error occurred (most likely the table couldn't be updated).
     # @param pos [Integer]  The position which the first newly inserted row will have.
     # @param numRows [Integer]  The number of rows to insert.
-    # @param updateLabels [true,false]  Currently not used.
-    # @return [true,false]
+    # @param updateLabels [Boolean]  Currently not used.
+    # @return [Boolean]
     def insert_rows(pos=0, numRows=1, updateLabels=true) end
     
     # Invalidates the cached attribute for the given cell.
@@ -2123,8 +2134,8 @@ module Wx::GRID
     #   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 [Wx::GridCellCoords] 
-    #   @param bottomRight [Wx::GridCellCoords] 
+    #   @param topLeft [Array(Integer, Integer)] 
+    #   @param bottomRight [Array(Integer, Integer)] 
     #   @return [void]
     # @overload refresh_block(topRow, leftCol, bottomRow, rightCol)
     #   This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
@@ -2140,8 +2151,8 @@ module Wx::GRID
     # @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().
     # @param size [Array(Integer, Integer), Wx::Size]  The size of the area on the {Wx::DC} that the rendered {Wx::GRID::Grid} should occupy. If not specified the drawing will be scaled to fit the available dc width or height. The {Wx::GRID::Grid}'s aspect ratio is maintained whether or not size is specified.
-    # @param topLeft [Wx::GridCellCoords]  The top left cell of the block to be drawn. Defaults to ( 0, 0 ).
-    # @param bottomRight [Wx::GridCellCoords]  The bottom right cell of the block to be drawn. Defaults to row and column counts.
+    # @param topLeft [Array(Integer, Integer)]  The top left cell of the block to be drawn. Defaults to ( 0, 0 ).
+    # @param bottomRight [Array(Integer, Integer)]  The bottom right cell of the block to be drawn. Defaults to row and column counts.
     # @param style [Integer]  A combination of values from {Wx::GRID::GridRenderStyle}.
     # @return [void]
     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
@@ -2151,14 +2162,14 @@ module Wx::GRID
     # See the {Wx::GRID::GridCellAttr} class for more information about controlling cell attributes.
     # @param row [Integer] 
     # @param col [Integer] 
-    # @param attr [Wx::GridCellAttr] 
+    # @param attr [Wx::GRID::GridCellAttr] 
     # @return [void]
     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::GridCellAttr] 
+    # @param attr [Wx::GRID::GridCellAttr] 
     # @return [void]
     def set_col_attr(col, attr) end
     
@@ -2173,7 +2184,7 @@ module Wx::GRID
     # The grid takes ownership of the attribute pointer.
     # See the {Wx::GRID::GridCellAttr} class for more information about controlling cell attributes.
     # @param row [Integer] 
-    # @param attr [Wx::GridCellAttr] 
+    # @param attr [Wx::GRID::GridCellAttr] 
     # @return [void]
     def set_row_attr(row, attr) end
     
@@ -2181,7 +2192,7 @@ module Wx::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] 
-    # @param gridWindow [Wx::GridWindow] 
+    # @param gridWindow [Wx::GRID::GridWindow] 
     # @return [Array<Integer>]
     def calc_row_labels_exposed(reg, gridWindow=nil) end
     
@@ -2189,7 +2200,7 @@ module Wx::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] 
-    # @param gridWindow [Wx::GridWindow] 
+    # @param gridWindow [Wx::GRID::GridWindow] 
     # @return [Array<Integer>]
     def calc_col_labels_exposed(reg, gridWindow=nil) end
     
@@ -2197,7 +2208,7 @@ module Wx::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] 
-    # @param gridWindow [Wx::GridWindow] 
+    # @param gridWindow [Wx::GRID::GridWindow] 
     # @return [Array<Array(Integer, Integer)>]
     def calc_cells_exposed(reg, gridWindow=nil) end
     
@@ -2212,14 +2223,14 @@ module Wx::GRID
     # 
     # @see Wx::GRID::Grid#get_sorting_column 
     # @param col [Integer] 
-    # @return [true,false]
+    # @return [Boolean]
     def is_sorting_by(col) end
     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 [true,false]
+    # @return [Boolean]
     def is_sort_order_ascending; end
     alias_method :sort_order_ascending?, :is_sort_order_ascending
     
@@ -2228,7 +2239,7 @@ module Wx::GRID
     # @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.
-    # @param ascending [true,false]  If true, display the ascending sort indicator, otherwise display the descending sort indicator.
+    # @param ascending [Boolean]  If true, display the ascending sort indicator, otherwise display the descending sort indicator.
     # @return [void]
     def set_sorting_column(col, ascending=true) end
     alias_method :sorting_column=, :set_sorting_column
@@ -2289,12 +2300,12 @@ module Wx::GRID
     alias_method :grid_col_header, :get_grid_col_header
     
     # Return true if native header control is currently being used.
-    # @return [true,false]
+    # @return [Boolean]
     def is_using_native_header; end
     alias_method :using_native_header?, :is_using_native_header
     
     # @param dc [Wx::DC] 
-    # @param attr [Wx::GridCellAttr] 
+    # @param attr [Wx::GRID::GridCellAttr] 
     # @return [void]
     def draw_cell_highlight(dc, attr) end
     
@@ -2379,5 +2390,251 @@ 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!
+  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)
+    #   Constructor taking a coordinates of the left top and the bottom right corners.
+    #   @param topRow [Integer] 
+    #   @param leftCol [Integer] 
+    #   @param bottomRow [Integer] 
+    #   @param rightCol [Integer] 
+    #   @return [Wx::GRID::GridBlockCoords]
+    def initialize(*args) end
+    
+    # Return the row of the left top corner.
+    # @return [Integer]
+    def get_top_row; end
+    alias_method :top_row, :get_top_row
+    
+    # Set the row of the left top corner.
+    # @param row [Integer] 
+    # @return [void]
+    def set_top_row(row) end
+    alias_method :top_row=, :set_top_row
+    
+    # Return the column of the left top corner.
+    # @return [Integer]
+    def get_left_col; end
+    alias_method :left_col, :get_left_col
+    
+    # Set the column of the left top corner.
+    # @param col [Integer] 
+    # @return [void]
+    def set_left_col(col) end
+    alias_method :left_col=, :set_left_col
+    
+    # Return the row of the bottom right corner.
+    # @return [Integer]
+    def get_bottom_row; end
+    alias_method :bottom_row, :get_bottom_row
+    
+    # Set the row of the bottom right corner.
+    # @param row [Integer] 
+    # @return [void]
+    def set_bottom_row(row) end
+    alias_method :bottom_row=, :set_bottom_row
+    
+    # Return the column of the bottom right corner.
+    # @return [Integer]
+    def get_right_col; end
+    alias_method :right_col, :get_right_col
+    
+    # Set the column of the bottom right corner.
+    # @param col [Integer] 
+    # @return [void]
+    def set_right_col(col) end
+    alias_method :right_col=, :set_right_col
+    
+    # Return the coordinates of the top left corner.
+    # @return [Array(Integer, Integer)]
+    def get_top_left; end
+    alias_method :top_left, :get_top_left
+    
+    # Return the coordinates of the bottom right corner.
+    # @return [Array(Integer, Integer)]
+    def get_bottom_right; end
+    alias_method :bottom_right, :get_bottom_right
+    
+    # Return the canonicalized block where top left coordinates is less then bottom right coordinates.
+    # @return [Wx::GRID::GridBlockCoords]
+    def canonicalize; end
+    
+    # Whether the blocks intersect.
+    # true, if the block intersects with the other, false, otherwise.
+    # @param other [Wx::GRID::GridBlockCoords] 
+    # @return [Boolean]
+    def intersects(other) end
+    
+    # @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}).
+    # @return [Wx::GRID::GridBlockDiffResult]
+    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]
+    def sym_difference(other) end
+    
+    # Equality operator.
+    # @param other [Wx::GRID::GridBlockCoords] 
+    # @return [Boolean]
+    def ==(other) end
+    
+  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!
+  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!
+  class GridSizesInfo < ::Object
+  
+    # Default size.
+    # 
+    # 
+    # @return [Integer]
+    def size_default; end
+    # Default size.
+    # 
+    # 
+    # @param val [Integer]
+    # @return [void]
+    def size_default=(val); end
+    
+    # Map with element indices as keys and their sizes as values.
+    # This map only contains the elements with non-default size.
+    # 
+    # @return [Hash]
+    def custom_sizes; end
+    # Map with element indices as keys and their sizes as values.
+    # This map only contains the elements with non-default size.
+    # 
+    # @param val [Hash]
+    # @return [void]
+    def custom_sizes=(val); end
+    
+    # @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.
+    #   @return [Wx::GRID::GridSizesInfo]
+    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]
+    def get_size(pos) end
+    alias_method :size, :get_size
+    
+  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.
+  # - Clip the cell contents, discarding the part which doesn't fit.
+  # - Ellipsize the cell contents, i.e. replace the non-fitting part with ellipsis (<code></code>...), putting the ellipsis at the end by default, but possibly at the beginning or in the middle.
+  # 
+  # The default behaviour is to overflow, use {Wx::GRID::Grid#set_default_cell_fit_mode} to change this, for example: 
+  # ```
+  #   grid->SetDefaultCellFitMode(wxGridFitMode::Clip());
+  # ```
+  # 
+  # 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!
+  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
+    alias_method :ellipsize_mode, :get_ellipsize_mode
+    
+    # Pseudo-constructor for object specifying clipping behaviour.
+    # @return [Wx::GRID::GridFitMode]
+    def self.clip; end
+    
+    # Pseudo-constructor for object specifying overflow behaviour.
+    # @return [Wx::GRID::GridFitMode]
+    def self.overflow; end
+    
+    # Pseudo-constructor for object specifying ellipsize behaviour.
+    # @param ellipsize [Wx::EllipsizeMode] 
+    # @return [Wx::GRID::GridFitMode]
+    def self.ellipsize(ellipsize=Wx::EllipsizeMode::ELLIPSIZE_END) end
+    
+  end # GridFitMode
+  
 
 end