wxruby3 0.9.0.pre.beta.2-x64-mingw-ucrt-3.2-3.2.2

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

@@ -0,0 +1,288 @@
+# :stopdoc:
+# This file is automatically generated by the WXRuby3 documentation 
+# generator. Do not alter this file.
+# :startdoc:
+
+
+module Wx::GRID
+
+  # The almost abstract base class for grid tables.
+  # A grid table is responsible for storing the grid data and, indirectly, grid cell attributes. The data can be stored in the way most convenient for the application but has to be provided in string form to {Wx::GRID::Grid}. It is also possible to provide cells values in other formats if appropriate, e.g. as numbers.
+  # This base class is not quite abstract as it implements a trivial strategy for storing the attributes by forwarding it to {Wx::GridCellAttrProvider} and also provides stubs for some other functions. However it does have a number of pure virtual methods which must be implemented in the derived classes.
+  # 
+  # === 
+  # 
+  # Category:  Grid Related Classes
+  # @see Wx::GRID::GridStringTable
+  # 
+  # 
+  class GridTableBase < Object
+  
+    # May be overridden to implement testing for empty cells.
+    # This method is used by the grid to test if the given cell is not used and so whether a neighbouring cell may overflow into it. By default it only returns true if the value of the given cell, as returned by {Wx::GRID::GridTableBase#get_value}, is empty.
+    # @param row [Integer] 
+    # @param col [Integer] 
+    # @return [true,false]
+    def is_empty_cell(row, col) end
+    alias_method :empty_cell?, :is_empty_cell
+    
+    # Same as {Wx::GRID::GridTableBase#is_empty_cell} but taking {Wx::GridCellCoords}.
+    # Notice that this method is not virtual, only {Wx::GRID::GridTableBase#is_empty_cell} should be overridden.
+    # @param coords [Wx::GridCellCoords] 
+    # @return [true,false]
+    def is_empty(coords) end
+    alias_method :empty?, :is_empty
+    
+    # Must be overridden to implement accessing the table values as text.
+    # @param row [Integer] 
+    # @param col [Integer] 
+    # @return [String]
+    def get_value(row, col) end
+    alias_method :value, :get_value
+    
+    # Must be overridden to implement setting the table values as text.
+    # @param row [Integer] 
+    # @param col [Integer] 
+    # @param value [String] 
+    # @return [void]
+    def set_value(row, col, value) end
+    
+    # Returns the type of the value in the given cell.
+    # By default all cells are strings and this method returns {Wx::GRID::GRID_VALUE_STRING}.
+    # @param row [Integer] 
+    # @param col [Integer] 
+    # @return [String]
+    def get_type_name(row, col) end
+    alias_method :type_name, :get_type_name
+    
+    # Returns true if the value of the given cell can be accessed as if it were of the specified type.
+    # By default the cells can only be accessed as strings. Note that a cell could be accessible in different ways, e.g. a numeric cell may return true for {Wx::GRID::GRID_VALUE_NUMBER} but also for {Wx::GRID::GRID_VALUE_STRING} indicating that the value can be coerced to a string form.
+    # @param row [Integer] 
+    # @param col [Integer] 
+    # @param typeName [String] 
+    # @return [true,false]
+    def can_get_value_as(row, col, typeName) end
+    alias_method :can_get_value_as?, :can_get_value_as
+    
+    # Returns true if the value of the given cell can be set as if it were of the specified type.
+    # 
+    # @see Wx::GRID::GridTableBase#can_get_value_as 
+    # @param row [Integer] 
+    # @param col [Integer] 
+    # @param typeName [String] 
+    # @return [true,false]
+    def can_set_value_as(row, col, typeName) end
+    alias_method :can_set_value_as?, :can_set_value_as
+    
+    # Returns the value of the given cell as a long.
+    # This should only be called if {Wx::GRID::GridTableBase#can_get_value_as} returns true when called with {Wx::GRID::GRID_VALUE_NUMBER} argument. Default implementation always return 0.
+    # @param row [Integer] 
+    # @param col [Integer] 
+    # @return [Integer]
+    def get_value_as_long(row, col) end
+    alias_method :value_as_long, :get_value_as_long
+    
+    # Returns the value of the given cell as a double.
+    # This should only be called if {Wx::GRID::GridTableBase#can_get_value_as} returns true when called with {Wx::GRID::GRID_VALUE_FLOAT} argument. Default implementation always return 0.0.
+    # @param row [Integer] 
+    # @param col [Integer] 
+    # @return [Float]
+    def get_value_as_double(row, col) end
+    alias_method :value_as_double, :get_value_as_double
+    
+    # Returns the value of the given cell as a boolean.
+    # This should only be called if {Wx::GRID::GridTableBase#can_get_value_as} returns true when called with {Wx::GRID::GRID_VALUE_BOOL} argument. Default implementation always return false.
+    # @param row [Integer] 
+    # @param col [Integer] 
+    # @return [true,false]
+    def get_value_as_bool(row, col) end
+    alias_method :value_as_bool, :get_value_as_bool
+    
+    # Sets the value of the given cell as a long.
+    # This should only be called if {Wx::GRID::GridTableBase#can_set_value_as} returns true when called with {Wx::GRID::GRID_VALUE_NUMBER} argument. Default implementation doesn't do anything.
+    # @param row [Integer] 
+    # @param col [Integer] 
+    # @param value [Integer] 
+    # @return [void]
+    def set_value_as_long(row, col, value) end
+    
+    # Sets the value of the given cell as a double.
+    # This should only be called if {Wx::GRID::GridTableBase#can_set_value_as} returns true when called with {Wx::GRID::GRID_VALUE_FLOAT} argument. Default implementation doesn't do anything.
+    # @param row [Integer] 
+    # @param col [Integer] 
+    # @param value [Float] 
+    # @return [void]
+    def set_value_as_double(row, col, value) end
+    
+    # Sets the value of the given cell as a boolean.
+    # This should only be called if {Wx::GRID::GridTableBase#can_set_value_as} returns true when called with {Wx::GRID::GRID_VALUE_BOOL} argument. Default implementation doesn't do anything.
+    # @param row [Integer] 
+    # @param col [Integer] 
+    # @param value [true,false] 
+    # @return [void]
+    def set_value_as_bool(row, col, value) end
+    
+    # Clear the table contents.
+    # This method is used by {Wx::GRID::Grid#clear_grid}.
+    # @return [void]
+    def clear; end
+    
+    # Insert additional rows into the table.
+    # @param pos [Integer]  The position of the first new row.
+    # @param numRows [Integer]  The number of rows to insert.
+    # @return [true,false]
+    def insert_rows(pos=0, numRows=1) end
+    
+    # Append additional rows at the end of the table.
+    # This method is provided in addition to {Wx::GRID::GridTableBase#insert_rows} as some data models may only support appending rows to them but not inserting them at arbitrary locations. In such case you may implement this method only and leave {Wx::GRID::GridTableBase#insert_rows} unimplemented.
+    # @param numRows [Integer]  The number of rows to add.
+    # @return [true,false]
+    def append_rows(numRows=1) end
+    
+    # Delete rows from the table.
+    # @param pos [Integer]  The first row to delete.
+    # @param numRows [Integer]  The number of rows to delete.
+    # @return [true,false]
+    def delete_rows(pos=0, numRows=1) end
+    
+    # Exactly the same as {Wx::GRID::GridTableBase#insert_rows} but for columns.
+    # @param pos [Integer] 
+    # @param numCols [Integer] 
+    # @return [true,false]
+    def insert_cols(pos=0, numCols=1) end
+    
+    # Exactly the same as {Wx::GRID::GridTableBase#append_rows} but for columns.
+    # @param numCols [Integer] 
+    # @return [true,false]
+    def append_cols(numCols=1) end
+    
+    # Exactly the same as {Wx::GRID::GridTableBase#delete_rows} but for columns.
+    # @param pos [Integer] 
+    # @param numCols [Integer] 
+    # @return [true,false]
+    def delete_cols(pos=0, numCols=1) end
+    
+    # Return the label of the specified row.
+    # @param row [Integer] 
+    # @return [String]
+    def get_row_label_value(row) end
+    alias_method :row_label_value, :get_row_label_value
+    
+    # Return the label of the specified column.
+    # @param col [Integer] 
+    # @return [String]
+    def get_col_label_value(col) end
+    alias_method :col_label_value, :get_col_label_value
+    
+    # Return the label of the grid's corner.
+    # @return [String]
+    def get_corner_label_value; end
+    alias_method :corner_label_value, :get_corner_label_value
+    
+    # Set the given label for the specified row.
+    # The default version does nothing, i.e. the label is not stored. You must override this method in your derived class if you wish {Wx::GRID::Grid#set_row_label_value} to work.
+    # @param row [Integer] 
+    # @param label [String] 
+    # @return [void]
+    def set_row_label_value(row, label) end
+    
+    # Exactly the same as {Wx::GRID::GridTableBase#set_row_label_value} but for columns.
+    # @param col [Integer] 
+    # @param label [String] 
+    # @return [void]
+    def set_col_label_value(col, label) end
+    
+    # Set the given label for the grid's corner.
+    # The default version does nothing, i.e. the label is not stored. You must override this method in your derived class if you wish {Wx::GRID::Grid#get_corner_label_value} to work.
+    # @param arg [String] 
+    # @return [void]
+    def set_corner_label_value(arg) end
+    alias_method :corner_label_value=, :set_corner_label_value
+    
+    # Return the attribute for the given cell.
+    # By default this function is simply forwarded to Wx::GridCellAttrProvider#get_attr but it may be overridden to handle attributes directly in the table.
+    # Prefer to use {Wx::GRID::GridTableBase#get_attr_ptr} to avoid the need to call DecRef() on the returned pointer manually.
+    # @param row [Integer] 
+    # @param col [Integer] 
+    # @param kind [Wx::GridCellAttr::wxAttrKind] 
+    # @return [Wx::GRID::GridCellAttr]
+    def get_attr(row, col, kind) end
+    alias_method :attr, :get_attr
+    
+    # Set attribute of the specified cell.
+    # By default this function is simply forwarded to Wx::GridCellAttrProvider#set_attr.
+    # The table takes ownership of attr, i.e. will call DecRef() on it.
+    # @param attr [Wx::GridCellAttr] 
+    # @param row [Integer] 
+    # @param col [Integer] 
+    # @return [void]
+    def set_attr(attr, row, col) end
+    
+    # Set attribute of the specified row.
+    # By default this function is simply forwarded to Wx::GridCellAttrProvider#set_row_attr.
+    # The table takes ownership of attr, i.e. will call DecRef() on it.
+    # @param attr [Wx::GridCellAttr] 
+    # @param row [Integer] 
+    # @return [void]
+    def set_row_attr(attr, row) end
+    
+    # Set attribute of the specified column.
+    # By default this function is simply forwarded to Wx::GridCellAttrProvider#set_col_attr.
+    # The table takes ownership of attr, i.e. will call DecRef() on it.
+    # @param attr [Wx::GridCellAttr] 
+    # @param col [Integer] 
+    # @return [void]
+    def set_col_attr(attr, col) end
+    
+    # Default constructor.
+    # @return [GridTableBase]
+    def initialize; end
+    
+    # Must be overridden to return the number of rows in the table.
+    # For backwards compatibility reasons, this method is not const. Use {Wx::GRID::GridTableBase#get_rows_count} instead of it in const methods of derived table classes.
+    # @return [Integer]
+    def get_number_rows; end
+    alias_method :number_rows, :get_number_rows
+    
+    # Must be overridden to return the number of columns in the table.
+    # For backwards compatibility reasons, this method is not const. Use {Wx::GRID::GridTableBase#get_cols_count} instead of it in const methods of derived table classes,
+    # @return [Integer]
+    def get_number_cols; end
+    alias_method :number_cols, :get_number_cols
+    
+    # Return the number of rows in the table.
+    # This method is not virtual and is only provided as a convenience for the derived classes which can't call {Wx::GRID::GridTableBase#get_number_rows} without a const_cast from their const methods.
+    # @return [Integer]
+    def get_rows_count; end
+    alias_method :rows_count, :get_rows_count
+    
+    # Return the number of columns in the table.
+    # This method is not virtual and is only provided as a convenience for the derived classes which can't call {Wx::GRID::GridTableBase#get_number_cols} without a const_cast from their const methods.
+    # @return [Integer]
+    def get_cols_count; end
+    alias_method :cols_count, :get_cols_count
+    
+    # Called by the grid when the table is associated with it.
+    # The default implementation stores the pointer and returns it from its {Wx::GRID::GridTableBase#get_view} and so only makes sense if the table cannot be associated with more than one grid at a time.
+    # @param grid [Wx::Grid] 
+    # @return [void]
+    def set_view(grid) end
+    alias_method :view=, :set_view
+    
+    # Returns the last grid passed to {Wx::GRID::GridTableBase#set_view}.
+    # @return [Wx::Grid]
+    def get_view; end
+    alias_method :view, :get_view
+    
+    # Override to return true if the same attribute can be used for measuring all cells in the given column.
+    # This function is provided for optimization purposes: it returns false by default, but can be overridden to return true when all the cells in the same grid column use sensibly the same attribute, i.e. they use the same renderer (either explicitly, or implicitly, due to their type as returned by {Wx::GRID::GridTableBase#get_type_name}) and the font of the same size.
+    # Returning true from this function allows AutoSizeColumns() to skip looking up the attribute and the renderer for each individual cell, which results in very noticeable performance improvements for the grids with many rows.
+    # @param col [Integer] 
+    # @return [true,false]
+    def can_measure_col_using_same_attr(col) end
+    alias_method :can_measure_col_using_same_attr?, :can_measure_col_using_same_attr
+    
+  end # GridTableBase
+  
+
+end

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

@@ -0,0 +1,73 @@
+# :stopdoc:
+# This file is automatically generated by the WXRuby3 documentation 
+# generator. Do not alter this file.
+# :startdoc:
+
+
+module Wx::GRID
+
+  # Message class used by the grid table to send requests and notifications to the grid view.
+  # A message object of this class must be sent to the grid using {Wx::GRID::Grid#process_table_message} every time the table changes, e.g. rows are added/deleted. The messages are just notifications and don't result in any actual changes but just allow the view to react to changes to the model.
+  # 
+  class GridTableMessage < ::Object
+  
+    # @overload initialize()
+    #   Default constructor initializes the object to invalid state.
+    #   @return [GridTableMessage]
+    # @overload initialize(table, id, comInt1=-1, comInt2=-1)
+    #   Constructor really initialize the message.
+    #   @param table [Wx::GridTableBase]  Pointer to the grid table
+    #   @param id [Integer]  One of {Wx::GRID::GridTableRequest} enum elements.
+    #   @param comInt1 [Integer]  For the insert/delete messages, position after which the rows or columns are inserted/deleted. For the append messages, the number of rows or columns that were appended.
+    #   @param comInt2 [Integer]  For the insert/deleted messages, number of rows or columns to be inserted/deleted. For the append messages, this parameter is not used.
+    #   @return [GridTableMessage]
+    def initialize(*args) end
+    
+    # Sets the table object.
+    # @param table [Wx::GridTableBase] 
+    # @return [void]
+    def set_table_object(table) end
+    alias_method :table_object=, :set_table_object
+    
+    # Gets the table object.
+    # @return [Wx::GridTableBase]
+    def get_table_object; end
+    alias_method :table_object, :get_table_object
+    
+    # Sets an id.
+    # @param id [Integer] 
+    # @return [void]
+    def set_id(id) end
+    alias_method :id=, :set_id
+    
+    # Gets an id.
+    # @return [Integer]
+    def get_id; end
+    alias_method :id, :get_id
+    
+    # Set the position after which the insertion/deletion occur.
+    # @param comInt1 [Integer] 
+    # @return [void]
+    def set_command_int(comInt1) end
+    alias_method :command_int=, :set_command_int
+    
+    # Get the position after which the insertion/deletion occur.
+    # @return [Integer]
+    def get_command_int; end
+    alias_method :command_int, :get_command_int
+    
+    # Set the number of rows to be inserted/deleted.
+    # @param comInt2 [Integer] 
+    # @return [void]
+    def set_command_int2(comInt2) end
+    alias_method :command_int2=, :set_command_int2
+    
+    # Get the number of rows to be inserted/deleted.
+    # @return [Integer]
+    def get_command_int2; end
+    alias_method :command_int2, :get_command_int2
+    
+  end # GridTableMessage
+  
+
+end

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

@@ -0,0 +1,298 @@
+# :stopdoc:
+# This file is automatically generated by the WXRuby3 documentation 
+# generator. Do not alter this file.
+# :startdoc:
+
+
+module Wx
+
+  # 
+  # 
+  DEFAULT_SPAN = nil
+  
+  # A {Wx::Sizer} that can lay out items in a virtual grid like a {Wx::FlexGridSizer} but in this case explicit positioning of the items is allowed using {Wx::GBPosition}, and items can optionally span more than one row and/or column using {Wx::GBSpan}.
+  # === 
+  # 
+  # Category:  Window Layout
+  # 
+  class GridBagSizer < FlexGridSizer
+  
+    # @overload add(window, pos, span=Wx::DEFAULT_SPAN, flag=0, border=0, userData=nil)
+    #   Adds the given item to the given position.
+    #   A valid pointer if the item was successfully placed at the given position, or NULL if something was already there.
+    #   @param window [Wx::Window] 
+    #   @param pos [Wx::GBPosition] 
+    #   @param span [Wx::GBSpan] 
+    #   @param flag [Integer] 
+    #   @param border [Integer] 
+    #   @param userData [Wx::Object] 
+    #   @return [Wx::SizerItem]
+    # @overload add(sizer, pos, span=Wx::DEFAULT_SPAN, flag=0, border=0, userData=nil)
+    #   Adds the given item to the given position.
+    #   A valid pointer if the item was successfully placed at the given position, or NULL if something was already there.
+    #   @param sizer [Wx::Sizer] 
+    #   @param pos [Wx::GBPosition] 
+    #   @param span [Wx::GBSpan] 
+    #   @param flag [Integer] 
+    #   @param border [Integer] 
+    #   @param userData [Wx::Object] 
+    #   @return [Wx::SizerItem]
+    # @overload add(width, height, pos, span=Wx::DEFAULT_SPAN, flag=0, border=0, userData=nil)
+    #   Adds a spacer to the given position.
+    #   width and height specify the dimension of the spacer to be added.
+    #   A valid pointer if the spacer was successfully placed at the given position, or NULL if something was already there.
+    #   @param width [Integer] 
+    #   @param height [Integer] 
+    #   @param pos [Wx::GBPosition] 
+    #   @param span [Wx::GBSpan] 
+    #   @param flag [Integer] 
+    #   @param border [Integer] 
+    #   @param userData [Wx::Object] 
+    #   @return [Wx::SizerItem]
+    def add(*args) end
+    
+    # @overload check_for_intersection(item, excludeItem=nil)
+    #   Look at all items and see if any intersect (or would overlap) the given item.
+    #   Returns true if so, false if there would be no overlap. If an excludeItem is given then it will not be checked for intersection, for example it may be the item we are checking the position of.
+    #   @param item [Wx::GBSizerItem] 
+    #   @param excludeItem [Wx::GBSizerItem] 
+    #   @return [true,false]
+    # @overload check_for_intersection(pos, span, excludeItem=nil)
+    #   Look at all items and see if any intersect (or would overlap) the given item.
+    #   Returns true if so, false if there would be no overlap. If an excludeItem is given then it will not be checked for intersection, for example it may be the item we are checking the position of.
+    #   @param pos [Wx::GBPosition] 
+    #   @param span [Wx::GBSpan] 
+    #   @param excludeItem [Wx::GBSizerItem] 
+    #   @return [true,false]
+    def check_for_intersection(*args) end
+    
+    # @overload find_item(window)
+    #   Find the sizer item for the given window or subsizer, returns NULL if not found.
+    #   (non-recursive)
+    #   @param window [Wx::Window] 
+    #   @return [Wx::GBSizerItem]
+    # @overload find_item(sizer)
+    #   Find the sizer item for the given window or subsizer, returns NULL if not found.
+    #   (non-recursive)
+    #   @param sizer [Wx::Sizer] 
+    #   @return [Wx::GBSizerItem]
+    def find_item(*args) end
+    
+    # @overload get_item_position(window)
+    #   Get the grid position of the specified item.
+    #   @param window [Wx::Window] 
+    #   @return [Wx::GBPosition]
+    # @overload get_item_position(sizer)
+    #   Get the grid position of the specified item.
+    #   @param sizer [Wx::Sizer] 
+    #   @return [Wx::GBPosition]
+    # @overload get_item_position(index)
+    #   Get the grid position of the specified item.
+    #   @param index [Integer] 
+    #   @return [Wx::GBPosition]
+    def get_item_position(*args) end
+    alias_method :item_position, :get_item_position
+    
+    # @overload get_item_span(window)
+    #   Get the row/col spanning of the specified item.
+    #   @param window [Wx::Window] 
+    #   @return [Wx::GBSpan]
+    # @overload get_item_span(sizer)
+    #   Get the row/col spanning of the specified item.
+    #   @param sizer [Wx::Sizer] 
+    #   @return [Wx::GBSpan]
+    # @overload get_item_span(index)
+    #   Get the row/col spanning of the specified item.
+    #   @param index [Integer] 
+    #   @return [Wx::GBSpan]
+    def get_item_span(*args) end
+    alias_method :item_span, :get_item_span
+    
+    # @overload set_item_position(window, pos)
+    #   Set the grid position of the specified item.
+    #   Returns true on success. If the move is not allowed (because an item is already there) then false is returned.
+    #   @param window [Wx::Window] 
+    #   @param pos [Wx::GBPosition] 
+    #   @return [true,false]
+    # @overload set_item_position(sizer, pos)
+    #   Set the grid position of the specified item.
+    #   Returns true on success. If the move is not allowed (because an item is already there) then false is returned.
+    #   @param sizer [Wx::Sizer] 
+    #   @param pos [Wx::GBPosition] 
+    #   @return [true,false]
+    # @overload set_item_position(index, pos)
+    #   Set the grid position of the specified item.
+    #   Returns true on success. If the move is not allowed (because an item is already there) then false is returned.
+    #   @param index [Integer] 
+    #   @param pos [Wx::GBPosition] 
+    #   @return [true,false]
+    def set_item_position(*args) end
+    
+    # @overload set_item_span(window, span)
+    #   Set the row/col spanning of the specified item.
+    #   Returns true on success. If the move is not allowed (because an item is already there) then false is returned.
+    #   @param window [Wx::Window] 
+    #   @param span [Wx::GBSpan] 
+    #   @return [true,false]
+    # @overload set_item_span(sizer, span)
+    #   Set the row/col spanning of the specified item.
+    #   Returns true on success. If the move is not allowed (because an item is already there) then false is returned.
+    #   @param sizer [Wx::Sizer] 
+    #   @param span [Wx::GBSpan] 
+    #   @return [true,false]
+    # @overload set_item_span(index, span)
+    #   Set the row/col spanning of the specified item.
+    #   Returns true on success. If the move is not allowed (because an item is already there) then false is returned.
+    #   @param index [Integer] 
+    #   @param span [Wx::GBSpan] 
+    #   @return [true,false]
+    def set_item_span(*args) end
+    
+    # Constructor, with optional parameters to specify the gap between the rows and columns.
+    # @param vgap [Integer] 
+    # @param hgap [Integer] 
+    # @return [GridBagSizer]
+    def initialize(vgap=0, hgap=0) end
+    
+    # Called when the managed size of the sizer is needed or when layout needs done.
+    # @return [Wx::Size]
+    def calc_min; end
+    
+    # Return the sizer item located at the point given in pt, or NULL if there is no item at that point.
+    # The (x,y) coordinates in pt correspond to the client coordinates of the window using the sizer for layout. (non-recursive)
+    # @param pt [Array(Integer, Integer), Wx::Point] 
+    # @return [Wx::GBSizerItem]
+    def find_item_at_point(pt) end
+    
+    # Return the sizer item for the given grid cell, or NULL if there is no item at that position.
+    # (non-recursive)
+    # @param pos [Wx::GBPosition] 
+    # @return [Wx::GBSizerItem]
+    def find_item_at_position(pos) end
+    
+    # Return the sizer item that has a matching user data (it only compares pointer values) or NULL if not found.
+    # (non-recursive)
+    # @param userData [Wx::Object] 
+    # @return [Wx::GBSizerItem]
+    def find_item_with_data(userData) end
+    
+    # Get the size of the specified cell, including hgap and vgap.
+    # Only valid after window layout has been performed.
+    # @param row [Integer] 
+    # @param col [Integer] 
+    # @return [Wx::Size]
+    def get_cell_size(row, col) end
+    alias_method :cell_size, :get_cell_size
+    
+    # Get the size used for cells in the grid with no item.
+    # @return [Wx::Size]
+    def get_empty_cell_size; end
+    alias_method :empty_cell_size, :get_empty_cell_size
+    
+    # Called when the managed size of the sizer is needed or when layout needs done.
+    # @param minSize [Array(Integer, Integer), Wx::Size] 
+    # @return [void]
+    def reposition_children(minSize) end
+    
+    # Set the size used for cells in the grid with no item.
+    # @param sz [Array(Integer, Integer), Wx::Size] 
+    # @return [void]
+    def set_empty_cell_size(sz) end
+    alias_method :empty_cell_size=, :set_empty_cell_size
+    
+  end # GridBagSizer
+  
+  # This class is used to hold the row and column spanning attributes of items in a {Wx::GridBagSizer}.
+  # === 
+  # 
+  # Category:  Window Layout
+  # 
+  class GBSpan < ::Object
+  
+    # @overload initialize()
+    #   Default constructor, setting the rowspan and colspan to (1,1) meaning that the item occupies one cell in each direction.
+    #   @return [GBSpan]
+    # @overload initialize(rowspan, colspan)
+    #   Construct a new {Wx::GBSpan}, setting the rowspan and colspan.
+    #   @param rowspan [Integer] 
+    #   @param colspan [Integer] 
+    #   @return [GBSpan]
+    def initialize(*args) end
+    
+    # Get the current colspan value.
+    # @return [Integer]
+    def get_colspan; end
+    alias_method :colspan, :get_colspan
+    
+    # Get the current rowspan value.
+    # @return [Integer]
+    def get_rowspan; end
+    alias_method :rowspan, :get_rowspan
+    
+    # Set a new colspan value.
+    # @param colspan [Integer] 
+    # @return [void]
+    def set_colspan(colspan) end
+    alias_method :colspan=, :set_colspan
+    
+    # Set a new rowspan value.
+    # @param rowspan [Integer] 
+    # @return [void]
+    def set_rowspan(rowspan) end
+    alias_method :rowspan=, :set_rowspan
+    
+    # Compare equality of two {Wx::GBSpans}.
+    # @param o [Wx::GBSpan] 
+    # @return [true,false]
+    def ==(o) end
+    
+  end # GBSpan
+  
+  # This class represents the position of an item in a virtual grid of rows and columns managed by a {Wx::GridBagSizer}.
+  # === 
+  # 
+  # Category:  Window Layout
+  # 
+  class GBPosition < ::Object
+  
+    # @overload initialize()
+    #   Default constructor, setting the row and column to (0,0).
+    #   @return [GBPosition]
+    # @overload initialize(row, col)
+    #   Construct a new {Wx::GBPosition}, setting the row and column.
+    #   @param row [Integer] 
+    #   @param col [Integer] 
+    #   @return [GBPosition]
+    def initialize(*args) end
+    
+    # Get the current column value.
+    # @return [Integer]
+    def get_col; end
+    alias_method :col, :get_col
+    
+    # Get the current row value.
+    # @return [Integer]
+    def get_row; end
+    alias_method :row, :get_row
+    
+    # Set a new column value.
+    # @param col [Integer] 
+    # @return [void]
+    def set_col(col) end
+    alias_method :col=, :set_col
+    
+    # Set a new row value.
+    # @param row [Integer] 
+    # @return [void]
+    def set_row(row) end
+    alias_method :row=, :set_row
+    
+    # Compare equality of two {Wx::GBPositions}.
+    # @param p [Wx::GBPosition] 
+    # @return [true,false]
+    def ==(p) end
+    
+  end # GBPosition
+  
+
+end