wxruby3 0.9.0.pre.beta.1-x64-mingw-ucrt-3.2

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

@@ -0,0 +1,494 @@
+# :stopdoc:
+# This file is automatically generated by the WXRuby3 documentation 
+# generator. Do not alter this file.
+# :startdoc:
+
+
+module Wx
+
+  # Anti-aliasing modes used by {Wx::GraphicsContext#set_antialias_mode}.
+  # 
+  # 
+  # 
+  class AntialiasMode < Wx::Enum
+  
+    # No anti-aliasing.
+    # 
+    ANTIALIAS_NONE = Wx::AntialiasMode.new(0)
+    
+    # The default anti-aliasing.
+    # 
+    ANTIALIAS_DEFAULT = Wx::AntialiasMode.new(1)
+    
+  end # AntialiasMode
+  
+  # Interpolation quality used by {Wx::GraphicsContext#set_interpolation_quality}.
+  # 
+  # 
+  # 
+  class InterpolationQuality < Wx::Enum
+  
+    # default interpolation, based on type of context, in general medium quality
+    # 
+    INTERPOLATION_DEFAULT = Wx::InterpolationQuality.new(0)
+    
+    # no interpolation
+    # 
+    INTERPOLATION_NONE = Wx::InterpolationQuality.new(1)
+    
+    # fast interpolation, suited for interactivity
+    # 
+    INTERPOLATION_FAST = Wx::InterpolationQuality.new(2)
+    
+    # better quality
+    # 
+    INTERPOLATION_GOOD = Wx::InterpolationQuality.new(3)
+    
+    # best quality, not suited for interactivity
+    # 
+    INTERPOLATION_BEST = Wx::InterpolationQuality.new(4)
+    
+  end # InterpolationQuality
+  
+  # Compositing is done using Porter-Duff compositions (see http://keithp.com/~keithp/porterduff/p253-porter.pdf) with {Wx::GraphicsContext#set_composition_mode}.
+  # 
+  # The description give a short equation on how the values of a resulting pixel are calculated. R = Result, S = Source, D = Destination, colors premultiplied with alpha Ra, Sa, Da their alpha components
+  # 
+  class CompositionMode < Wx::Enum
+  
+    # Indicates invalid or unsupported composition mode.
+    # 
+    COMPOSITION_INVALID = Wx::CompositionMode.new(-1)
+    
+    # R = 0
+    # 
+    COMPOSITION_CLEAR = Wx::CompositionMode.new(0)
+    
+    # R = S
+    # 
+    COMPOSITION_SOURCE = Wx::CompositionMode.new(1)
+    
+    # R = S + D*(1 - Sa)
+    # 
+    COMPOSITION_OVER = Wx::CompositionMode.new(2)
+    
+    # R = S*Da
+    # 
+    COMPOSITION_IN = Wx::CompositionMode.new(3)
+    
+    # R = S*(1 - Da)
+    # 
+    COMPOSITION_OUT = Wx::CompositionMode.new(4)
+    
+    # R = S*Da + D*(1 - Sa)
+    # 
+    COMPOSITION_ATOP = Wx::CompositionMode.new(5)
+    
+    # R = D, essentially a noop
+    # 
+    COMPOSITION_DEST = Wx::CompositionMode.new(6)
+    
+    # R = S*(1 - Da) + D
+    # 
+    COMPOSITION_DEST_OVER = Wx::CompositionMode.new(7)
+    
+    # R = D*Sa
+    # 
+    COMPOSITION_DEST_IN = Wx::CompositionMode.new(8)
+    
+    # R = D*(1 - Sa)
+    # 
+    COMPOSITION_DEST_OUT = Wx::CompositionMode.new(9)
+    
+    # R = S*(1 - Da) + D*Sa
+    # 
+    COMPOSITION_DEST_ATOP = Wx::CompositionMode.new(10)
+    
+    # R = S*(1 - Da) + D*(1 - Sa)
+    # 
+    COMPOSITION_XOR = Wx::CompositionMode.new(11)
+    
+    # R = S + D
+    # 
+    COMPOSITION_ADD = Wx::CompositionMode.new(12)
+    
+    # Result is the absolute value of the difference between the source and the destination.
+    # 
+    COMPOSITION_DIFF = Wx::CompositionMode.new(13)
+    
+  end # CompositionMode
+  
+  # Used to indicate what kind of gradient is set in a {Wx::GraphicsPenInfo} object.
+  # 
+  # 
+  # 
+  class GradientType < Wx::Enum
+  
+    # 
+    # 
+    GRADIENT_NONE = Wx::GradientType.new(0)
+    
+    # 
+    # 
+    GRADIENT_LINEAR = Wx::GradientType.new(1)
+    
+    # 
+    # 
+    GRADIENT_RADIAL = Wx::GradientType.new(2)
+    
+  end # GradientType
+  
+  # 
+  # 
+  NULL_GRAPHICS_PEN = nil
+  
+  # 
+  # 
+  NULL_GRAPHICS_BRUSH = nil
+  
+  # 
+  # 
+  NULL_GRAPHICS_FONT = nil
+  
+  # 
+  # 
+  NULL_GRAPHICS_BITMAP = nil
+  
+  # 
+  # 
+  NULL_GRAPHICS_MATRIX = nil
+  
+  # 
+  # 
+  NULL_GRAPHICS_PATH = nil
+  
+  # This class is the superclass of native graphics objects like pens etc.
+  # It allows reference counting. Not instantiated by user code.
+  # === 
+  # 
+  # Category:  Graphics Device Interface (GDI)
+  # @see Wx::GraphicsBrush
+  # @see  Wx::GraphicsPen
+  # @see  Wx::GraphicsMatrix
+  # @see  Wx::GraphicsPath 
+  # 
+  # 
+  class GraphicsObject < Object
+  
+    # 
+    # false if this object is valid, otherwise returns true.
+    # @return [true,false]
+    def is_null; end
+    alias_method :null?, :is_null
+    
+  end # GraphicsObject
+  
+  # A {Wx::GraphicsPen} is a native representation of a pen.
+  # The contents are specific and private to the respective renderer. Instances are ref counted and can therefore be assigned as usual. The only way to get a valid instance is via {Wx::GraphicsContext#create_pen} or Wx::GraphicsRenderer#create_pen.
+  # === 
+  # 
+  # Category:  Graphics Device Interface (GDI)
+  # 
+  class GraphicsPen < GraphicsObject
+  
+  end # GraphicsPen
+  
+  # A {Wx::GraphicsBrush} is a native representation of a brush.
+  # The contents are specific and private to the respective renderer. Instances are ref counted and can therefore be assigned as usual. The only way to get a valid instance is via {Wx::GraphicsContext#create_brush} or Wx::GraphicsRenderer#create_brush.
+  # === 
+  # 
+  # Category:  Graphics Device Interface (GDI)
+  # 
+  class GraphicsBrush < GraphicsObject
+  
+  end # GraphicsBrush
+  
+  # A {Wx::GraphicsPath} is a native representation of a geometric path.
+  # The contents are specific and private to the respective renderer. Instances are reference counted and can therefore be assigned as usual. The only way to get a valid instance is by using {Wx::GraphicsContext#create_path} or Wx::GraphicsRenderer#create_path.
+  # === 
+  # 
+  # Category:  Graphics Device Interface (GDI)
+  # 
+  class GraphicsPath < GraphicsObject
+  
+    # @overload add_arc(x, y, r, startAngle, endAngle, clockwise)
+    #   Adds an arc of a circle.
+    #   The circle is defined by the coordinates of its centre (x, y) or c and its radius r. The arc goes from the starting angle startAngle to endAngle either clockwise or counter-clockwise depending on the value of clockwise argument.
+    #   The angles are measured in radians but, contrary to the usual mathematical convention, are always clockwise from the horizontal axis.
+    #   If for clockwise arc endAngle is less than startAngle it will be progressively increased by 2*pi until it is greater than startAngle. If for counter-clockwise arc endAngle is greater than startAngle it will be progressively decreased by 2*pi until it is less than startAngle.
+    #   If there is a current point set, an initial line segment will be added to the path to connect the current point to the beginning of the arc.
+    #   @param x [Float] 
+    #   @param y [Float] 
+    #   @param r [Float] 
+    #   @param startAngle [Float] 
+    #   @param endAngle [Float] 
+    #   @param clockwise [true,false] 
+    #   @return [void]
+    # @overload add_arc(c, r, startAngle, endAngle, clockwise)
+    #   Adds an arc of a circle.
+    #   The circle is defined by the coordinates of its centre (x, y) or c and its radius r. The arc goes from the starting angle startAngle to endAngle either clockwise or counter-clockwise depending on the value of clockwise argument.
+    #   The angles are measured in radians but, contrary to the usual mathematical convention, are always clockwise from the horizontal axis.
+    #   If for clockwise arc endAngle is less than startAngle it will be progressively increased by 2*pi until it is greater than startAngle. If for counter-clockwise arc endAngle is greater than startAngle it will be progressively decreased by 2*pi until it is less than startAngle.
+    #   If there is a current point set, an initial line segment will be added to the path to connect the current point to the beginning of the arc.
+    #   @param c [Array<Float,Float>] 
+    #   @param r [Float] 
+    #   @param startAngle [Float] 
+    #   @param endAngle [Float] 
+    #   @param clockwise [true,false] 
+    #   @return [void]
+    def add_arc(*args) end
+    
+    # Adds an arc (of a circle with radius r) that is tangent to the line connecting current point and (x1, y1) and to the line connecting (x1, y1) and (x2, y2).
+    # If the current point and the starting point of the arc are different, a straight line connecting these points is also appended. If there is no current point before the call to {Wx::GraphicsPath#add_arc_to_point} this function will behave as if preceded by a call to MoveToPoint(0, 0). After this call the current point will be at the ending point of the arc.
+    # @param x1 [Float] 
+    # @param y1 [Float] 
+    # @param x2 [Float] 
+    # @param y2 [Float] 
+    # @param r [Float] 
+    # @return [void]
+    def add_arc_to_point(x1, y1, x2, y2, r) end
+    
+    # Appends a circle around (x,y) with radius r as a new closed subpath.
+    # After this call the current point will be at (x+r, y).
+    # @param x [Float] 
+    # @param y [Float] 
+    # @param r [Float] 
+    # @return [void]
+    def add_circle(x, y, r) end
+    
+    # @overload add_curve_to_point(cx1, cy1, cx2, cy2, x, y)
+    #   Adds a cubic bezier curve from the current point, using two control points and an end point.
+    #   If there is no current point before the call to {Wx::GraphicsPath#add_curve_to_point} this function will behave as if preceded by a call to MoveToPoint(cx1, cy1).
+    #   @param cx1 [Float] 
+    #   @param cy1 [Float] 
+    #   @param cx2 [Float] 
+    #   @param cy2 [Float] 
+    #   @param x [Float] 
+    #   @param y [Float] 
+    #   @return [void]
+    # @overload add_curve_to_point(c1, c2, e)
+    #   Adds a cubic bezier curve from the current point, using two control points and an end point.
+    #   If there is no current point before the call to {Wx::GraphicsPath#add_curve_to_point} this function will behave as if preceded by a call to MoveToPoint(c1).
+    #   @param c1 [Array<Float,Float>] 
+    #   @param c2 [Array<Float,Float>] 
+    #   @param e [Array<Float,Float>] 
+    #   @return [void]
+    def add_curve_to_point(*args) end
+    
+    # Appends an ellipse fitting into the passed in rectangle as a new closed subpath.
+    # After this call the current point will be at (x+w, y+h/2).
+    # @param x [Float] 
+    # @param y [Float] 
+    # @param w [Float] 
+    # @param h [Float] 
+    # @return [void]
+    def add_ellipse(x, y, w, h) end
+    
+    # @overload add_line_to_point(x, y)
+    #   Adds a straight line from the current point to (x,y).
+    #   If current point is not yet set before the call to {Wx::GraphicsPath#add_line_to_point} this function will behave as {Wx::GraphicsPath#move_to_point}.
+    #   @param x [Float] 
+    #   @param y [Float] 
+    #   @return [void]
+    # @overload add_line_to_point(p)
+    #   Adds a straight line from the current point to p.
+    #   If current point is not yet set before the call to {Wx::GraphicsPath#add_line_to_point} this function will behave as {Wx::GraphicsPath#move_to_point}.
+    #   @param p [Array<Float,Float>] 
+    #   @return [void]
+    def add_line_to_point(*args) end
+    
+    # Adds another path onto the current path.
+    # After this call the current point will be at the added path's current point. For Direct2D the path being appended shouldn't contain a started non-empty subpath when this function is called.
+    # @param path [Wx::GraphicsPath] 
+    # @return [void]
+    def add_path(path) end
+    
+    # Adds a quadratic bezier curve from the current point, using a control point and an end point.
+    # If there is no current point before the call to {Wx::GraphicsPath#add_quad_curve_to_point} this function will behave as if preceded by a call to MoveToPoint(cx, cy).
+    # @param cx [Float] 
+    # @param cy [Float] 
+    # @param x [Float] 
+    # @param y [Float] 
+    # @return [void]
+    def add_quad_curve_to_point(cx, cy, x, y) end
+    
+    # Appends a rectangle as a new closed subpath.
+    # After this call the current point will be at (x, y).
+    # @param x [Float] 
+    # @param y [Float] 
+    # @param w [Float] 
+    # @param h [Float] 
+    # @return [void]
+    def add_rectangle(x, y, w, h) end
+    
+    # Appends a rounded rectangle as a new closed subpath.
+    # If radius equals 0 this function will behave as {Wx::GraphicsPath#add_rectangle}, otherwise after this call the current point will be at (x+w, y+h/2).
+    # @param x [Float] 
+    # @param y [Float] 
+    # @param w [Float] 
+    # @param h [Float] 
+    # @param radius [Float] 
+    # @return [void]
+    def add_rounded_rectangle(x, y, w, h, radius) end
+    
+    # Closes the current sub-path.
+    # After this call the current point will be at the joined endpoint of the sub-path.
+    # @return [void]
+    def close_subpath; end
+    
+    # @overload contains(c, fillStyle=Wx::ODDEVEN_RULE)
+    #   
+    #   true if the point is within the path.
+    #   @param c [Array<Float,Float>] 
+    #   @param fillStyle [PolygonFillMode] 
+    #   @return [true,false]
+    # @overload contains(x, y, fillStyle=Wx::ODDEVEN_RULE)
+    #   
+    #   true if the point is within the path.
+    #   @param x [Float] 
+    #   @param y [Float] 
+    #   @param fillStyle [PolygonFillMode] 
+    #   @return [true,false]
+    def contains(*args) end
+    
+    # Gets the bounding box enclosing all points (possibly including control points).
+    # @param x [Float] 
+    # @param y [Float] 
+    # @param w [Float] 
+    # @param h [Float] 
+    # @return [void]
+    def get_box(x, y, w, h) end
+    alias_method :box, :get_box
+    
+    # Gets the last point of the current path, (0,0) if not yet set.
+    # @param x [Float] 
+    # @param y [Float] 
+    # @return [void]
+    def get_current_point(x, y) end
+    alias_method :current_point, :get_current_point
+    
+    # @overload move_to_point(x, y)
+    #   Begins a new subpath at (x,y).
+    #   @param x [Float] 
+    #   @param y [Float] 
+    #   @return [void]
+    # @overload move_to_point(p)
+    #   Begins a new subpath at p.
+    #   @param p [Array<Float,Float>] 
+    #   @return [void]
+    def move_to_point(*args) end
+    
+    # Transforms each point of this path by the matrix.
+    # For Direct2D the current path shouldn't contain a started non-empty subpath when this function is called.
+    # @param matrix [Wx::GraphicsMatrix] 
+    # @return [void]
+    def transform(matrix) end
+    
+  end # GraphicsPath
+  
+  # A {Wx::GraphicsFont} is a native representation of a font.
+  # The contents are specific and private to the respective renderer. Instances are ref counted and can therefore be assigned as usual. The only way to get a valid instance is via {Wx::GraphicsContext#create_font} or Wx::GraphicsRenderer#create_font.
+  # === 
+  # 
+  # Category:  Graphics Device Interface (GDI)
+  # 
+  class GraphicsFont < GraphicsObject
+  
+  end # GraphicsFont
+  
+  # A {Wx::GraphicsMatrix} is a native representation of an affine matrix.
+  # The contents are specific and private to the respective renderer. Instances are ref counted and can therefore be assigned as usual. The only way to get a valid instance is via {Wx::GraphicsContext#create_matrix} or Wx::GraphicsRenderer#create_matrix.
+  # === 
+  # 
+  # Category:  Graphics Device Interface (GDI)
+  # 
+  class GraphicsMatrix < GraphicsObject
+  
+    # Concatenates the matrix passed with the current matrix.
+    # The effect of the resulting transformation is to first apply the transformation in t to the coordinates and then apply the transformation in the current matrix to the coordinates.
+    # 
+    #   // matrix = t x matrix
+    # @param t [Wx::GraphicsMatrix]  The parameter matrix is the multiplicand.
+    # @return [void]
+    def concat(t) end
+    
+    # Returns the component values of the matrix via the argument pointers.
+    # @return [Array(Float,Float,Float,Float,Float,Float)]
+    def get; end
+    
+    # Inverts the matrix.
+    # @return [void]
+    def invert; end
+    
+    # Returns true if the elements of the transformation matrix are equal.
+    # @param t [Wx::GraphicsMatrix] 
+    # @return [true,false]
+    def is_equal(t) end
+    alias_method :equal?, :is_equal
+    
+    # Return true if this is the identity matrix.
+    # @return [true,false]
+    def is_identity; end
+    alias_method :identity?, :is_identity
+    
+    # Rotates this matrix clockwise (in radians).
+    # @param angle [Float]  Rotation angle in radians, clockwise.
+    # @return [void]
+    def rotate(angle) end
+    
+    # Scales this matrix.
+    # @param xScale [Float] 
+    # @param yScale [Float] 
+    # @return [void]
+    def scale(xScale, yScale) end
+    
+    # Sets the matrix to the respective values (default values are the identity matrix).
+    # @param a [Float] 
+    # @param b [Float] 
+    # @param c [Float] 
+    # @param d [Float] 
+    # @param tx [Float] 
+    # @param ty [Float] 
+    # @return [void]
+    def set(a=1.0, b=0.0, c=0.0, d=1.0, tx=0.0, ty=0.0) end
+    
+    # Applies this matrix to a distance (ie.
+    # performs all transforms except translations).
+    # @param dx [Float] 
+    # @param dy [Float] 
+    # @return [void]
+    def transform_distance(dx, dy) end
+    
+    # Applies this matrix to a point.
+    # @param x [Float] 
+    # @param y [Float] 
+    # @return [void]
+    def transform_point(x, y) end
+    
+    # Translates this matrix.
+    # @param dx [Float] 
+    # @param dy [Float] 
+    # @return [void]
+    def translate(dx, dy) end
+    
+  end # GraphicsMatrix
+  
+  # Represents a bitmap.
+  # The objects of this class are not created directly but only via {Wx::GraphicsContext} or {Wx::GraphicsRenderer} CreateBitmap(), CreateBitmapFromImage() or CreateSubBitmap() methods. They can subsequently be used with {Wx::GraphicsContext#draw_bitmap}. The only other operation is testing for the bitmap validity which can be performed using {Wx::GraphicsBitmap#is_null} method inherited from the base class.
+  # 
+  class GraphicsBitmap < GraphicsObject
+  
+    # Default constructor creates an invalid bitmap.
+    # @return [GraphicsBitmap]
+    def initialize; end
+    
+    # Return the contents of this bitmap as {Wx::Image}.
+    # Using this method is more efficient than converting {Wx::GraphicsBitmap} to {Wx::Bitmap} first and then to {Wx::Image} and can be useful if, for example, you want to save {Wx::GraphicsBitmap} as a disk file in a format not directly supported by {Wx::Bitmap}.
+    # Invalid image is returned if the bitmap is invalid.
+    # @return [Wx::Image]
+    def convert_to_image; end
+    
+  end # GraphicsBitmap
+  
+
+end

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

@@ -0,0 +1,173 @@
+# ----------------------------------------------------------------------------
+# This file is automatically generated by the WXRuby3 documentation 
+# generator. Do not alter this file.
+# ----------------------------------------------------------------------------
+
+
+class Wx::EvtHandler
+
+  # @!group GRID Event handler methods
+  
+  # The user is about to change the data in a cell. The new cell value as string is available from {Wx::GRID::GridEvent#get_string} event object method. This event can be vetoed if the change is not allowed. Processes a {Wx::GRID::EVT_GRID_CELL_CHANGING} event type. 
+  # @param [String,Symbol,Method,Proc] meth (name of) method or handler proc
+  # @yieldparam [Wx::GRID::GridEvent] event the event to handle
+  def evt_grid_cell_changing(meth = nil, &block) end
+  
+  # The user changed the data in a cell. The old cell value as string is available from {Wx::GRID::GridEvent#get_string} event object method. Notice that vetoing this event still works for backwards compatibility reasons but any new code should only veto EVT_GRID_CELL_CHANGING event and not this one. Processes a {Wx::GRID::EVT_GRID_CELL_CHANGED} event type. 
+  # @param [String,Symbol,Method,Proc] meth (name of) method or handler proc
+  # @yieldparam [Wx::GRID::GridEvent] event the event to handle
+  def evt_grid_cell_changed(meth = nil, &block) end
+  
+  # The user clicked a cell with the left mouse button. Processes a {Wx::GRID::EVT_GRID_CELL_LEFT_CLICK} event type. 
+  # @param [String,Symbol,Method,Proc] meth (name of) method or handler proc
+  # @yieldparam [Wx::GRID::GridEvent] event the event to handle
+  def evt_grid_cell_left_click(meth = nil, &block) end
+  
+  # The user double-clicked a cell with the left mouse button. Processes a {Wx::GRID::EVT_GRID_CELL_LEFT_DCLICK} event type. 
+  # @param [String,Symbol,Method,Proc] meth (name of) method or handler proc
+  # @yieldparam [Wx::GRID::GridEvent] event the event to handle
+  def evt_grid_cell_left_dclick(meth = nil, &block) end
+  
+  # The user clicked a cell with the right mouse button. Processes a {Wx::GRID::EVT_GRID_CELL_RIGHT_CLICK} event type. 
+  # @param [String,Symbol,Method,Proc] meth (name of) method or handler proc
+  # @yieldparam [Wx::GRID::GridEvent] event the event to handle
+  def evt_grid_cell_right_click(meth = nil, &block) end
+  
+  # The user double-clicked a cell with the right mouse button. Processes a {Wx::GRID::EVT_GRID_CELL_RIGHT_DCLICK} event type. 
+  # @param [String,Symbol,Method,Proc] meth (name of) method or handler proc
+  # @yieldparam [Wx::GRID::GridEvent] event the event to handle
+  def evt_grid_cell_right_dclick(meth = nil, &block) end
+  
+  # The editor for a cell was hidden. Processes a {Wx::GRID::EVT_GRID_EDITOR_HIDDEN} event type. 
+  # @param [String,Symbol,Method,Proc] meth (name of) method or handler proc
+  # @yieldparam [Wx::GRID::GridEvent] event the event to handle
+  def evt_grid_editor_hidden(meth = nil, &block) end
+  
+  # The editor for a cell was shown. Processes a {Wx::GRID::EVT_GRID_EDITOR_SHOWN} event type. 
+  # @param [String,Symbol,Method,Proc] meth (name of) method or handler proc
+  # @yieldparam [Wx::GRID::GridEvent] event the event to handle
+  def evt_grid_editor_shown(meth = nil, &block) end
+  
+  # The user clicked a label with the left mouse button. Processes a {Wx::GRID::EVT_GRID_LABEL_LEFT_CLICK} event type. 
+  # @param [String,Symbol,Method,Proc] meth (name of) method or handler proc
+  # @yieldparam [Wx::GRID::GridEvent] event the event to handle
+  def evt_grid_label_left_click(meth = nil, &block) end
+  
+  # The user double-clicked a label with the left mouse button. Processes a {Wx::GRID::EVT_GRID_LABEL_LEFT_DCLICK} event type. 
+  # @param [String,Symbol,Method,Proc] meth (name of) method or handler proc
+  # @yieldparam [Wx::GRID::GridEvent] event the event to handle
+  def evt_grid_label_left_dclick(meth = nil, &block) end
+  
+  # The user clicked a label with the right mouse button. Processes a {Wx::GRID::EVT_GRID_LABEL_RIGHT_CLICK} event type. 
+  # @param [String,Symbol,Method,Proc] meth (name of) method or handler proc
+  # @yieldparam [Wx::GRID::GridEvent] event the event to handle
+  def evt_grid_label_right_click(meth = nil, &block) end
+  
+  # The user double-clicked a label with the right mouse button. Processes a {Wx::GRID::EVT_GRID_LABEL_RIGHT_DCLICK} event type. 
+  # @param [String,Symbol,Method,Proc] meth (name of) method or handler proc
+  # @yieldparam [Wx::GRID::GridEvent] event the event to handle
+  def evt_grid_label_right_dclick(meth = nil, &block) end
+  
+  # The given cell is about to be made current, either by user or by the program via a call to {Wx::GRID::Grid#set_grid_cursor} or {Wx::GRID::Grid#go_to_cell}. The event can be vetoed to prevent this from happening and {Wx::GRID::Grid#get_grid_cursor_coords} still returns the previous current cell coordinates during the event handler execution, while the new ones are available via the event object {Wx::GRID::GridEvent#get_row} and {Wx::GRID::GridEvent#get_col} functions. Processes a {Wx::GRID::EVT_GRID_SELECT_CELL} event type. 
+  # @param [String,Symbol,Method,Proc] meth (name of) method or handler proc
+  # @yieldparam [Wx::GRID::GridEvent] event the event to handle
+  def evt_grid_select_cell(meth = nil, &block) end
+  
+  # The user tries to change the order of the rows in the grid by dragging the row specified by {Wx::GRID::GridEvent#get_row}. This event can be vetoed to either prevent the user from reordering the row change completely (but notice that if you don't want to allow it at all, you simply shouldn't call {Wx::GRID::Grid#enable_drag_row_move} in the first place), vetoed but handled in some way in the handler, e.g. by really moving the row to the new position at the associated table level, or allowed to proceed in which case {Wx::GRID::Grid#set_row_pos} is used to reorder the rows display order without affecting the use of the row indices otherwise. This event macro corresponds to {Wx::GRID::EVT_GRID_ROW_MOVE} event type. It is only available since wxWidgets 3.1.7. 
+  # Processes a {Wx::GRID::EVT_GRID_ROW_MOVE} event.
+  # @param [String,Symbol,Method,Proc] meth (name of) method or handler proc
+  # @yieldparam [Wx::GRID::GridEvent] event the event to handle
+  def evt_grid_row_move(meth = nil, &block) end
+  
+  # The user tries to change the order of the columns in the grid by dragging the column specified by {Wx::GRID::GridEvent#get_col}. This event can be vetoed to either prevent the user from reordering the column change completely (but notice that if you don't want to allow it at all, you simply shouldn't call {Wx::GRID::Grid#enable_drag_col_move} in the first place), vetoed but handled in some way in the handler, e.g. by really moving the column to the new position at the associated table level, or allowed to proceed in which case {Wx::GRID::Grid#set_col_pos} is used to reorder the columns display order without affecting the use of the column indices otherwise. This event macro corresponds to {Wx::GRID::EVT_GRID_COL_MOVE} event type. 
+  # Processes a {Wx::GRID::EVT_GRID_COL_MOVE} event.
+  # @param [String,Symbol,Method,Proc] meth (name of) method or handler proc
+  # @yieldparam [Wx::GRID::GridEvent] event the event to handle
+  def evt_grid_col_move(meth = nil, &block) end
+  
+  # This event is generated when a column is clicked by the user and its name is explained by the fact that the custom reaction to a click on a column is to sort the grid contents by this column. However the grid itself has no special support for sorting and it's up to the handler of this event to update the associated table. But if the event is handled (and not vetoed) the grid supposes that the table was indeed resorted and updates the column to indicate the new sort order and refreshes itself. This event macro corresponds to {Wx::GRID::EVT_GRID_COL_SORT} event type. 
+  # Processes a {Wx::GRID::EVT_GRID_COL_SORT} event.
+  # @param [String,Symbol,Method,Proc] meth (name of) method or handler proc
+  # @yieldparam [Wx::GRID::GridEvent] event the event to handle
+  def evt_grid_col_sort(meth = nil, &block) end
+  
+  # This event is generated when the user presses TAB or Shift-TAB in the grid. It can be used to customize the simple default TAB handling logic, e.g. to go to the next non-empty cell instead of just the next cell. See also {Wx::GRID::Grid#set_tab_behaviour}. This event is new since wxWidgets 2.9.5. 
+  # Processes a {Wx::GRID::EVT_GRID_TABBING} event.
+  # @param [String,Symbol,Method,Proc] meth (name of) method or handler proc
+  # @yieldparam [Wx::GRID::GridEvent] event the event to handle
+  def evt_grid_tabbing(meth = nil, &block) end
+  
+  # The user resized a column, corresponds to {Wx::GRID::EVT_GRID_COL_SIZE} event type. 
+  # Processes a {Wx::GRID::EVT_GRID_CMD_COL_SIZE} event.
+  # @param [Integer,Wx::Enum,Wx::Window,Wx::MenuItem,Wx::ToolBarTool,Wx::Timer] id window/control id
+  # @param [String,Symbol,Method,Proc] meth (name of) method or handler proc
+  # @yieldparam [Wx::GRID::GridSizeEvent] event the event to handle
+  def evt_grid_cmd_col_size(id, meth = nil, &block) end
+  
+  # The user resized a row, corresponds to {Wx::GRID::EVT_GRID_ROW_SIZE} event type. 
+  # Processes a {Wx::GRID::EVT_GRID_CMD_ROW_SIZE} event.
+  # @param [Integer,Wx::Enum,Wx::Window,Wx::MenuItem,Wx::ToolBarTool,Wx::Timer] id window/control id
+  # @param [String,Symbol,Method,Proc] meth (name of) method or handler proc
+  # @yieldparam [Wx::GRID::GridSizeEvent] event the event to handle
+  def evt_grid_cmd_row_size(id, meth = nil, &block) end
+  
+  # This event is sent when a row must be resized to its best size, e.g. when the user double clicks the row divider. The default implementation simply resizes the row to fit the row label (but not its contents as this could be too slow for big grids). This macro corresponds to {Wx::GRID::EVT_GRID_ROW_AUTO_SIZE} event type and is new since wxWidgets 3.1.7. 
+  # Processes a {Wx::GRID::EVT_GRID_ROW_AUTO_SIZE} event.
+  # @param [String,Symbol,Method,Proc] meth (name of) method or handler proc
+  # @yieldparam [Wx::GRID::GridSizeEvent] event the event to handle
+  def evt_grid_row_auto_size(meth = nil, &block) end
+  
+  # Same as EVT_GRID_CMD_COL_SIZE() but uses {Wx::StandardID::ID_ANY} id. 
+  # Processes a {Wx::GRID::EVT_GRID_COL_SIZE} event.
+  # @param [String,Symbol,Method,Proc] meth (name of) method or handler proc
+  # @yieldparam [Wx::GRID::GridSizeEvent] event the event to handle
+  def evt_grid_col_size(meth = nil, &block) end
+  
+  # This event is sent when a column must be resized to its best size, e.g. when the user double clicks the column divider. The default implementation simply resizes the column to fit the column label (but not its contents as this could be too slow for big grids). This macro corresponds to {Wx::GRID::EVT_GRID_COL_AUTO_SIZE} event type and is new since wxWidgets 2.9.5. 
+  # Processes a {Wx::GRID::EVT_GRID_COL_AUTO_SIZE} event.
+  # @param [String,Symbol,Method,Proc] meth (name of) method or handler proc
+  # @yieldparam [Wx::GRID::GridSizeEvent] event the event to handle
+  def evt_grid_col_auto_size(meth = nil, &block) end
+  
+  # Same as EVT_GRID_CMD_ROW_SIZE() but uses {Wx::StandardID::ID_ANY} id. 
+  # Processes a {Wx::GRID::EVT_GRID_ROW_SIZE} event.
+  # @param [String,Symbol,Method,Proc] meth (name of) method or handler proc
+  # @yieldparam [Wx::GRID::GridSizeEvent] event the event to handle
+  def evt_grid_row_size(meth = nil, &block) end
+  
+  # The editor for a cell was created. Processes a {Wx::GRID::EVT_GRID_EDITOR_CREATED} event type. 
+  # @param [String,Symbol,Method,Proc] meth (name of) method or handler proc
+  # @yieldparam [Wx::GRID::GridEditorCreatedEvent] event the event to handle
+  def evt_grid_editor_created(meth = nil, &block) end
+  
+  # The editor for a cell was created; variant taking a window identifier. Processes a {Wx::GRID::EVT_GRID_EDITOR_CREATED} event type. 
+  # @param [Integer,Wx::Enum,Wx::Window,Wx::MenuItem,Wx::ToolBarTool,Wx::Timer] id window/control id
+  # @param [String,Symbol,Method,Proc] meth (name of) method or handler proc
+  # @yieldparam [Wx::GRID::GridEditorCreatedEvent] event the event to handle
+  def evt_grid_cmd_editor_created(id, meth = nil, &block) end
+  
+  # The user is selecting a group of contiguous cells. Processes a {Wx::GRID::EVT_GRID_RANGE_SELECTING} event type. This event is available in wxWidgets 3.1.5 and later only. 
+  # @param [String,Symbol,Method,Proc] meth (name of) method or handler proc
+  # @yieldparam [Wx::GRID::GridRangeSelectEvent] event the event to handle
+  def evt_grid_range_selecting(meth = nil, &block) end
+  
+  # The user is selecting a group of contiguous cells; variant taking a window identifier. Processes a {Wx::GRID::EVT_GRID_RANGE_SELECTING} event type. This event is available in wxWidgets 3.1.5 and later only. 
+  # @param [Integer,Wx::Enum,Wx::Window,Wx::MenuItem,Wx::ToolBarTool,Wx::Timer] id window/control id
+  # @param [String,Symbol,Method,Proc] meth (name of) method or handler proc
+  # @yieldparam [Wx::GRID::GridRangeSelectEvent] event the event to handle
+  def evt_grid_cmd_range_selecting(id, meth = nil, &block) end
+  
+  # The user selected a group of contiguous cells. Processes a {Wx::GRID::EVT_GRID_RANGE_SELECTED} event type. This event is available in wxWidgets 3.1.5 and later only and was called {Wx::EVT_GRID_RANGE_SELECT} in the previous versions. 
+  # @param [String,Symbol,Method,Proc] meth (name of) method or handler proc
+  # @yieldparam [Wx::GRID::GridRangeSelectEvent] event the event to handle
+  def evt_grid_range_selected(meth = nil, &block) end
+  
+  # The user selected a group of contiguous cells; variant taking a window identifier. Processes a {Wx::GRID::EVT_GRID_RANGE_SELECTED} event type. This event is available in wxWidgets 3.1.5 and later only and was called {Wx::EVT_GRID_CMD_RANGE_SELECT} in the previous versions. 
+  # @param [Integer,Wx::Enum,Wx::Window,Wx::MenuItem,Wx::ToolBarTool,Wx::Timer] id window/control id
+  # @param [String,Symbol,Method,Proc] meth (name of) method or handler proc
+  # @yieldparam [Wx::GRID::GridRangeSelectEvent] event the event to handle
+  def evt_grid_cmd_range_selected(id, meth = nil, &block) end
+  
+  # @!endgroup
+
+end