wxruby3 1.6.0 → 1.7.0

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

@@ -0,0 +1,323 @@
+# :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 nil if something was already there.
+    #   @param window [Wx::Window] 
+    #   @param pos [Array(Integer, Integer), Wx::GBPosition] 
+    #   @param span [Array(Integer, Integer), Wx::GBSpan] 
+    #   @param flag [Integer] 
+    #   @param border [Integer] 
+    #   @param userData [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 nil if something was already there.
+    #   @param sizer [Wx::Sizer] 
+    #   @param pos [Array(Integer, Integer), Wx::GBPosition] 
+    #   @param span [Array(Integer, Integer), Wx::GBSpan] 
+    #   @param flag [Integer] 
+    #   @param border [Integer] 
+    #   @param userData [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 nil if something was already there.
+    #   @param width [Integer] 
+    #   @param height [Integer] 
+    #   @param pos [Array(Integer, Integer), Wx::GBPosition] 
+    #   @param span [Array(Integer, Integer), Wx::GBSpan] 
+    #   @param flag [Integer] 
+    #   @param border [Integer] 
+    #   @param userData [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 [Boolean]
+    # @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 [Array(Integer, Integer), Wx::GBPosition] 
+    #   @param span [Array(Integer, Integer), Wx::GBSpan] 
+    #   @param excludeItem [Wx::GBSizerItem] 
+    #   @return [Boolean]
+    def check_for_intersection(*args) end
+    
+    # @overload find_item(window)
+    #   Find the sizer item for the given window or subsizer, returns nil 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 nil 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 [Array(Integer, Integer), Wx::GBPosition] 
+    #   @return [Boolean]
+    # @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 [Array(Integer, Integer), Wx::GBPosition] 
+    #   @return [Boolean]
+    # @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 [Array(Integer, Integer), Wx::GBPosition] 
+    #   @return [Boolean]
+    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 [Array(Integer, Integer), Wx::GBSpan] 
+    #   @return [Boolean]
+    # @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 [Array(Integer, Integer), Wx::GBSpan] 
+    #   @return [Boolean]
+    # @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 [Array(Integer, Integer), Wx::GBSpan] 
+    #   @return [Boolean]
+    def set_item_span(*args) end
+    
+    # @overload initialize(vgap=0, hgap=0)
+    #   Constructor, with optional parameters to specify the gap between the rows and columns.
+    #   @param vgap [Integer] 
+    #   @param hgap [Integer] 
+    #   @return [Wx::GridBagSizer]
+    # @overload initialize(vgap=0, hgap=0, &block)
+    #   Constructor, with optional parameters to specify the gap between the rows and columns.
+    #   @param vgap [Integer] 
+    #   @param hgap [Integer] 
+    #   @yieldparam [Wx::GridBagSizer] sizer new Sizer instance
+    #   @return [Wx::GridBagSizer]
+    def initialize(*args) 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 nil 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 nil if there is no item at that position.
+    # 
+    # (non-recursive)
+    # @param pos [Array(Integer, Integer), 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 nil if not found.
+    # 
+    # (non-recursive)
+    # @param userData [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
+  # 
+  # 
+  # @note This class is <b>untracked</b> and should not be derived from nor instances extended!
+  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 [Wx::GBSpan]
+    # @overload initialize(rowspan, colspan)
+    #   Construct a new {Wx::GBSpan}, setting the rowspan and colspan.
+    #   @param rowspan [Integer] 
+    #   @param colspan [Integer] 
+    #   @return [Wx::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 [Array(Integer, Integer), Wx::GBSpan] 
+    # @return [Boolean]
+    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
+  # 
+  # 
+  # @note This class is <b>untracked</b> and should not be derived from nor instances extended!
+  class GBPosition < ::Object
+  
+    # @overload initialize()
+    #   Default constructor, setting the row and column to (0,0).
+    #   @return [Wx::GBPosition]
+    # @overload initialize(row, col)
+    #   Construct a new {Wx::GBPosition}, setting the row and column.
+    #   @param row [Integer] 
+    #   @param col [Integer] 
+    #   @return [Wx::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 [Array(Integer, Integer), Wx::GBPosition] 
+    # @return [Boolean]
+    def ==(p) end
+    
+  end # GBPosition
+  
+
+end

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

@@ -0,0 +1,195 @@
+# :stopdoc:
+# This file is automatically generated by the WXRuby3 documentation 
+# generator. Do not alter this file.
+# :startdoc:
+
+
+module Wx
+
+  # A grid sizer is a sizer which lays out its children in a two-dimensional table with all table fields having the same size, i.e.
+  # 
+  # the width of each field is the width of the widest child, the height of each field is the height of the tallest child.
+  # 
+  # Category:  Window Layout
+  # @see Wx::Sizer
+  # @see  Sizers Overview 
+  # 
+  # 
+  class GridSizer < Sizer
+  
+    # @overload initialize(cols, vgap, hgap)
+    #   {Wx::GridSizer} constructors.
+    #   
+    #   Usually only the number of columns in the flex grid sizer needs to be specified using cols argument. The number of rows will be deduced automatically depending on the number of the elements added to the sizer.
+    #   If a constructor form with rows parameter is used (and the value of rows argument is not zero, meaning "unspecified") the sizer will check that no more than <code>cols*rows</code> elements are added to it, i.e. that no more than the given number of rows is used. Adding less than maximally allowed number of items is not an error however.
+    #   Finally, it is also possible to specify the number of rows and use 0 for cols. In this case, the sizer will use the given fixed number of rows and as many columns as necessary.
+    #   The gap (or vgap and hgap, which correspond to the height and width of the {Wx::Size} object) argument defines the size of the padding between the rows (its vertical component, or vgap) and columns (its horizontal component, or hgap), in pixels.
+    #   @param cols [Integer] 
+    #   @param vgap [Integer] 
+    #   @param hgap [Integer] 
+    #   @return [Wx::GridSizer]
+    # @overload initialize(cols, vgap, hgap, &block)
+    #   {Wx::GridSizer} constructors.
+    #   
+    #   Usually only the number of columns in the flex grid sizer needs to be specified using cols argument. The number of rows will be deduced automatically depending on the number of the elements added to the sizer.
+    #   If a constructor form with rows parameter is used (and the value of rows argument is not zero, meaning "unspecified") the sizer will check that no more than <code>cols*rows</code> elements are added to it, i.e. that no more than the given number of rows is used. Adding less than maximally allowed number of items is not an error however.
+    #   Finally, it is also possible to specify the number of rows and use 0 for cols. In this case, the sizer will use the given fixed number of rows and as many columns as necessary.
+    #   The gap (or vgap and hgap, which correspond to the height and width of the {Wx::Size} object) argument defines the size of the padding between the rows (its vertical component, or vgap) and columns (its horizontal component, or hgap), in pixels.
+    #   @param cols [Integer] 
+    #   @param vgap [Integer] 
+    #   @param hgap [Integer] 
+    #   @yieldparam [Wx::GridSizer] sizer new Sizer instance
+    #   @return [Wx::GridSizer]
+    # @overload initialize(cols, gap=(Wx::Size.new(0, 0)))
+    #   {Wx::GridSizer} constructors.
+    #   
+    #   Usually only the number of columns in the flex grid sizer needs to be specified using cols argument. The number of rows will be deduced automatically depending on the number of the elements added to the sizer.
+    #   If a constructor form with rows parameter is used (and the value of rows argument is not zero, meaning "unspecified") the sizer will check that no more than <code>cols*rows</code> elements are added to it, i.e. that no more than the given number of rows is used. Adding less than maximally allowed number of items is not an error however.
+    #   Finally, it is also possible to specify the number of rows and use 0 for cols. In this case, the sizer will use the given fixed number of rows and as many columns as necessary.
+    #   The gap (or vgap and hgap, which correspond to the height and width of the {Wx::Size} object) argument defines the size of the padding between the rows (its vertical component, or vgap) and columns (its horizontal component, or hgap), in pixels.
+    #   @param cols [Integer] 
+    #   @param gap [Array(Integer, Integer), Wx::Size] 
+    #   @return [Wx::GridSizer]
+    # @overload initialize(cols, gap=(Wx::Size.new(0, 0)), &block)
+    #   {Wx::GridSizer} constructors.
+    #   
+    #   Usually only the number of columns in the flex grid sizer needs to be specified using cols argument. The number of rows will be deduced automatically depending on the number of the elements added to the sizer.
+    #   If a constructor form with rows parameter is used (and the value of rows argument is not zero, meaning "unspecified") the sizer will check that no more than <code>cols*rows</code> elements are added to it, i.e. that no more than the given number of rows is used. Adding less than maximally allowed number of items is not an error however.
+    #   Finally, it is also possible to specify the number of rows and use 0 for cols. In this case, the sizer will use the given fixed number of rows and as many columns as necessary.
+    #   The gap (or vgap and hgap, which correspond to the height and width of the {Wx::Size} object) argument defines the size of the padding between the rows (its vertical component, or vgap) and columns (its horizontal component, or hgap), in pixels.
+    #   @param cols [Integer] 
+    #   @param gap [Array(Integer, Integer), Wx::Size] 
+    #   @yieldparam [Wx::GridSizer] sizer new Sizer instance
+    #   @return [Wx::GridSizer]
+    # @overload initialize(rows, cols, vgap, hgap)
+    #   {Wx::GridSizer} constructors.
+    #   
+    #   Usually only the number of columns in the flex grid sizer needs to be specified using cols argument. The number of rows will be deduced automatically depending on the number of the elements added to the sizer.
+    #   If a constructor form with rows parameter is used (and the value of rows argument is not zero, meaning "unspecified") the sizer will check that no more than <code>cols*rows</code> elements are added to it, i.e. that no more than the given number of rows is used. Adding less than maximally allowed number of items is not an error however.
+    #   Finally, it is also possible to specify the number of rows and use 0 for cols. In this case, the sizer will use the given fixed number of rows and as many columns as necessary.
+    #   The gap (or vgap and hgap, which correspond to the height and width of the {Wx::Size} object) argument defines the size of the padding between the rows (its vertical component, or vgap) and columns (its horizontal component, or hgap), in pixels.
+    #   @param rows [Integer] 
+    #   @param cols [Integer] 
+    #   @param vgap [Integer] 
+    #   @param hgap [Integer] 
+    #   @return [Wx::GridSizer]
+    # @overload initialize(rows, cols, vgap, hgap, &block)
+    #   {Wx::GridSizer} constructors.
+    #   
+    #   Usually only the number of columns in the flex grid sizer needs to be specified using cols argument. The number of rows will be deduced automatically depending on the number of the elements added to the sizer.
+    #   If a constructor form with rows parameter is used (and the value of rows argument is not zero, meaning "unspecified") the sizer will check that no more than <code>cols*rows</code> elements are added to it, i.e. that no more than the given number of rows is used. Adding less than maximally allowed number of items is not an error however.
+    #   Finally, it is also possible to specify the number of rows and use 0 for cols. In this case, the sizer will use the given fixed number of rows and as many columns as necessary.
+    #   The gap (or vgap and hgap, which correspond to the height and width of the {Wx::Size} object) argument defines the size of the padding between the rows (its vertical component, or vgap) and columns (its horizontal component, or hgap), in pixels.
+    #   @param rows [Integer] 
+    #   @param cols [Integer] 
+    #   @param vgap [Integer] 
+    #   @param hgap [Integer] 
+    #   @yieldparam [Wx::GridSizer] sizer new Sizer instance
+    #   @return [Wx::GridSizer]
+    # @overload initialize(rows, cols, gap)
+    #   {Wx::GridSizer} constructors.
+    #   
+    #   Usually only the number of columns in the flex grid sizer needs to be specified using cols argument. The number of rows will be deduced automatically depending on the number of the elements added to the sizer.
+    #   If a constructor form with rows parameter is used (and the value of rows argument is not zero, meaning "unspecified") the sizer will check that no more than <code>cols*rows</code> elements are added to it, i.e. that no more than the given number of rows is used. Adding less than maximally allowed number of items is not an error however.
+    #   Finally, it is also possible to specify the number of rows and use 0 for cols. In this case, the sizer will use the given fixed number of rows and as many columns as necessary.
+    #   The gap (or vgap and hgap, which correspond to the height and width of the {Wx::Size} object) argument defines the size of the padding between the rows (its vertical component, or vgap) and columns (its horizontal component, or hgap), in pixels.
+    #   @param rows [Integer] 
+    #   @param cols [Integer] 
+    #   @param gap [Array(Integer, Integer), Wx::Size] 
+    #   @return [Wx::GridSizer]
+    # @overload initialize(rows, cols, gap, &block)
+    #   {Wx::GridSizer} constructors.
+    #   
+    #   Usually only the number of columns in the flex grid sizer needs to be specified using cols argument. The number of rows will be deduced automatically depending on the number of the elements added to the sizer.
+    #   If a constructor form with rows parameter is used (and the value of rows argument is not zero, meaning "unspecified") the sizer will check that no more than <code>cols*rows</code> elements are added to it, i.e. that no more than the given number of rows is used. Adding less than maximally allowed number of items is not an error however.
+    #   Finally, it is also possible to specify the number of rows and use 0 for cols. In this case, the sizer will use the given fixed number of rows and as many columns as necessary.
+    #   The gap (or vgap and hgap, which correspond to the height and width of the {Wx::Size} object) argument defines the size of the padding between the rows (its vertical component, or vgap) and columns (its horizontal component, or hgap), in pixels.
+    #   @param rows [Integer] 
+    #   @param cols [Integer] 
+    #   @param gap [Array(Integer, Integer), Wx::Size] 
+    #   @yieldparam [Wx::GridSizer] sizer new Sizer instance
+    #   @return [Wx::GridSizer]
+    def initialize(*args) end
+    
+    # Returns the number of columns that has been specified for the sizer.
+    # 
+    # Returns zero if the sizer is automatically adjusting the number of columns depending on number of its children. To get the effective number of columns or rows being currently used, see {Wx::GridSizer#get_effective_cols_count}
+    # @return [Integer]
+    def get_cols; end
+    alias_method :cols, :get_cols
+    
+    # Returns the number of rows that has been specified for the sizer.
+    # 
+    # Returns zero if the sizer is automatically adjusting the number of rows depending on number of its children. To get the effective number of columns or rows being currently used, see {Wx::GridSizer#get_effective_rows_count}.
+    # @return [Integer]
+    def get_rows; end
+    alias_method :rows, :get_rows
+    
+    # Returns the number of columns currently used by the sizer.
+    # 
+    # This will depend on the number of children the sizer has if the sizer is automatically adjusting the number of columns/rows.
+    # Note that if the sizer is not empty, the number of rows must have been set, otherwise this function triggers an assert failure and returns 0.
+    # @return [Integer]
+    def get_effective_cols_count; end
+    alias_method :effective_cols_count, :get_effective_cols_count
+    
+    # Returns the number of rows currently used by the sizer.
+    # 
+    # This will depend on the number of children the sizer has if the sizer is automatically adjusting the number of columns/rows.
+    # Note that if the sizer is not empty, the number of columns must have been set, otherwise this function triggers an assert failure and returns 0.
+    # @return [Integer]
+    def get_effective_rows_count; end
+    alias_method :effective_rows_count, :get_effective_rows_count
+    
+    # Returns the horizontal gap (in pixels) between cells in the sizer.
+    # @return [Integer]
+    def get_h_gap; end
+    alias_method :h_gap, :get_h_gap
+    
+    # Returns the vertical gap (in pixels) between the cells in the sizer.
+    # @return [Integer]
+    def get_v_gap; end
+    alias_method :v_gap, :get_v_gap
+    
+    # Sets the number of columns in the sizer.
+    # @param cols [Integer] 
+    # @return [void]
+    def set_cols(cols) end
+    alias_method :cols=, :set_cols
+    
+    # Sets the horizontal gap (in pixels) between cells in the sizer.
+    # @param gap [Integer] 
+    # @return [void]
+    def set_h_gap(gap) end
+    alias_method :h_gap=, :set_h_gap
+    
+    # Sets the number of rows in the sizer.
+    # @param rows [Integer] 
+    # @return [void]
+    def set_rows(rows) end
+    alias_method :rows=, :set_rows
+    
+    # Sets the vertical gap (in pixels) between the cells in the sizer.
+    # @param gap [Integer] 
+    # @return [void]
+    def set_v_gap(gap) end
+    alias_method :v_gap=, :set_v_gap
+    
+    # This method is abstract and has to be overwritten by any derived class.
+    # 
+    # Here, the sizer will do the actual calculation of its children's minimal sizes.
+    # @return [Wx::Size]
+    def calc_min; end
+    
+    # Method which must be overridden in the derived sizer classes.
+    # 
+    # The implementation should reposition the children using the current total size available to the sizer (m_size) and the size computed by the last call to {Wx::GridSizer#calc_min}.
+    # Note that you should never call this method directly, call {Wx::GridSizer#layout} instead if you need to manually update the sizer elements positions. This method is only called by wxWidgets itself.
+    # @param minSize [Array(Integer, Integer), Wx::Size] 
+    # @return [void]
+    def reposition_children(minSize) end
+    
+  end # GridSizer
+  
+
+end

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

@@ -0,0 +1,159 @@
+# :stopdoc:
+# This file is automatically generated by the WXRuby3 documentation 
+# generator. Do not alter this file.
+# :startdoc:
+
+
+module Wx
+
+  # A generic implementation of the GUI event loop.
+  # 
+  # Category:  Application and Process Management
+  # 
+  class GUIEventLoop < ::Object
+  
+    # @return [Wx::GUIEventLoop]
+    def initialize; end
+    
+    # Start the event loop, return the exit code when it is finished.
+    # 
+    # Logically, this method calls {Wx::GUIEventLoop#dispatch} in a loop until it returns false and also takes care of generating idle events during each loop iteration. However not all implementations of this class really implement it like this (e.g. WXGTK does not) so you shouldn't rely on {Wx::GUIEventLoop#dispatch} being called from inside this function.
+    # The argument passed to {Wx::GUIEventLoop#exit} which terminated this event loop.
+    # @return [Integer]
+    def run; end
+    
+    # Return true if this event loop is currently running.
+    # 
+    # Notice that even if this event loop hasn't terminated yet but has just spawned a nested (e.g. modal) event loop, this method would return false.
+    # @return [Boolean]
+    def is_running; end
+    alias_method :running?, :is_running
+    
+    # Use this to check whether the event loop was successfully created before using it.
+    # @return [Boolean]
+    def is_ok; end
+    alias_method :ok?, :is_ok
+    
+    # Exit the currently running loop with the given exit code.
+    # 
+    # The loop will exit, i.e. its {Wx::GUIEventLoop#run} method will return, during the next event loop iteration.
+    # Notice that this method can only be used if this event loop is the currently running one, i.e. its {Wx::GUIEventLoop#is_running} returns true. If this is not the case, an assert failure is triggered and nothing is done as outer event loops can't be exited from immediately. Use {Wx::GUIEventLoop#schedule_exit} if you'd like to exit this loop even if it doesn't run currently.
+    # @param rc [Integer] 
+    # @return [void]
+    def exit(rc=0) end
+    
+    # Schedule an exit from the loop with the given exit code.
+    # 
+    # This method is similar to {Wx::GUIEventLoop#exit} but can be called even if this event loop is not the currently running one  and if it is the active loop, then it works in exactly the same way as {Wx::GUIEventLoop#exit}.
+    # The loop will exit as soon as the control flow returns to it, i.e. after any nested loops terminate.
+    # @param rc [Integer] 
+    # @return [void]
+    def schedule_exit(rc=0) end
+    
+    # Return true if any events are available.
+    # 
+    # If this method returns true, calling {Wx::GUIEventLoop#dispatch} will not block.
+    # 
+    # <div class="wxrb-note">
+    # <b>Note:</b>
+    # <p>This function always returns false under {Wx::Qt} since 3.3.0 
+    # </p>
+    # </div>
+    # @return [Boolean]
+    def pending; end
+    
+    # Dispatches the next event in the windowing system event queue.
+    # 
+    # Blocks until an event appears if there are none currently (use {Wx::GUIEventLoop#pending} if this is not wanted).
+    # This can be used for programming event loops, e.g.
+    # 
+    # ```ruby
+    #   while evt_loop.pending
+    #     evt_loop.dispatch
+    # ```
+    # 
+    # Notice that since wxWidgets 3.3.0, {Wx::GUIEventLoop#pending} always returns false under {Wx::Qt}. Therefore, the above code should be replaced with the following instead:
+    # 
+    # ```ruby
+    #   while evt_loop.pending
+    #     evt_loop.dispatch
+    # ```
+    # 
+    # false if the event loop should stop and true otherwise.
+    # @see Wx::GUIEventLoop#pending
+    # @see  Wx::EventLoopBase 
+    # @return [Boolean]
+    def dispatch; end
+    
+    # Dispatch an event but not wait longer than the specified timeout for it.
+    # 
+    # If an event is received before the specified timeout expires, it is processed and the function returns 1 normally or 0 if the event loop should quite. Otherwise, i.e. if the timeout expires, the functions returns -1 without processing any events.
+    # 
+    # 1 if an event was processed, 0 if the event loop should quit or -1 if the timeout expired.
+    # @param timeout [Integer]  The maximal time to wait for the events in milliseconds.
+    # @return [Integer]
+    def dispatch_timeout(timeout) end
+    
+    # Called by wxWidgets to wake up the event loop even if it is currently blocked inside {Wx::GUIEventLoop#dispatch}.
+    # @return [void]
+    def wake_up; end
+    
+    # Makes sure that idle events are sent again.
+    # @return [void]
+    def wake_up_idle; end
+    
+    # This virtual function is called when the application becomes idle and normally just sends {Wx::IdleEvent} to all interested parties.
+    # 
+    # It should return true if more idle events are needed, false if not.
+    # @return [Boolean]
+    def process_idle; end
+    
+    # Returns true if called from inside {Wx::GUIEventLoop#yield} or from inside {Wx::GUIEventLoop#yield_for}.
+    # @return [Boolean]
+    def is_yielding; end
+    alias_method :yielding?, :is_yielding
+    
+    # Yields control to pending messages in the windowing system.
+    # 
+    # This can be useful, for example, when a time-consuming process writes to a text window. Without an occasional yield, the text window will not be updated properly, and on systems with cooperative multitasking, other processes will not respond.
+    # Caution should be exercised, however, since yielding may allow the user to perform actions which are not compatible with the current task. Disabling menu items or whole menus during processing can avoid unwanted reentrance of code: see {Wx::SafeYield} for a better function.
+    # Note that {Wx::GUIEventLoop#yield} will not flush the message logs. This is intentional as calling {Wx::GUIEventLoop#yield} is usually done to quickly update the screen and popping up a message box dialog may be undesirable. If you do wish to flush the log messages immediately (otherwise it will be done during the next idle loop iteration), call {Wx::Log.flush_active}.
+    # If onlyIfNeeded parameter is true and the flow control is already inside {Wx::GUIEventLoop#yield}, i.e. {Wx::GUIEventLoop#is_yielding} returns true, the method just silently returns false and doesn't do anything.
+    # @param onlyIfNeeded [Boolean] 
+    # @return [Boolean]
+    def yield(onlyIfNeeded=false) end
+    
+    # Works like {Wx::GUIEventLoop#yield} with onlyIfNeeded == true, except that it allows the caller to specify a mask of the {Wx::EventCategory} values which indicates which events should be processed and which should instead be "delayed" (i.e.
+    # 
+    # processed by the main loop later).
+    # Note that this is a safer alternative to {Wx::GUIEventLoop#yield} since it ensures that only the events you're interested to will be processed; i.e. this method helps to avoid unwanted reentrancies.
+    # Note that currently only WXMSW and WXGTK do support selective yield of native events coming from the underlying GUI toolkit. wxWidgets events posted using {Wx::EvtHandler#add_pending_event} or {Wx::EvtHandler#queue_event} are instead selectively processed by all ports.
+    # 
+    # <div class="wxrb-note">
+    # <b>Note:</b>
+    # <p>Under WXMSW, if eventsToProcess doesn't include {Wx::EventCategory::EVT_CATEGORY_TIMER}, events from one-off timers may be lost, so it's recommended to either include this category in the argument or use repeatedly firing timers instead.
+    # </p>
+    # </div>
+    # @see Wx::Event#get_event_category 
+    # @param eventsToProcess [Integer] 
+    # @return [Boolean]
+    def yield_for(eventsToProcess) end
+    
+    # Returns true if the given event category is allowed inside a {Wx::GUIEventLoop#yield_for} call (i.e.
+    # 
+    # compares the given category against the last mask passed to {Wx::GUIEventLoop#yield_for}).
+    # @see Wx::Event#get_event_category 
+    # @param cat [Wx::EventCategory] 
+    # @return [Boolean]
+    def is_event_allowed_inside_yield(cat) end
+    alias_method :event_allowed_inside_yield?, :is_event_allowed_inside_yield
+    
+    # Returns true if this is the main loop executed by {Wx::App#on_run}.
+    # @return [Boolean]
+    def is_main; end
+    alias_method :main?, :is_main
+    
+  end # GUIEventLoop
+  
+
+end