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

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

@@ -231,29 +231,20 @@ module Wx
     
     # Returns bounding box of the current clipping region.
     # - If clipping region is empty, then empty rectangle is returned (x, y, w, h are set to zero).
-    # @param x [Float] 
-    # @param y [Float] 
-    # @param w [Float] 
-    # @param h [Float] 
-    # @return [void]
-    def get_clip_box(x, y, w, h) end
+    # @return [Array(Float,Float,Float,Float)]
+    def get_clip_box; end
     alias_method :clip_box, :get_clip_box
     
-    # @overload create_matrix(a=1.0, b=0.0, c=0.0, d=1.0, tx=0.0, ty=0.0)
-    #   Creates a native affine transformation matrix from the passed in values.
-    #   The default parameters result in an identity matrix.
-    #   @param a [Float] 
-    #   @param b [Float] 
-    #   @param c [Float] 
-    #   @param d [Float] 
-    #   @param tx [Float] 
-    #   @param ty [Float] 
-    #   @return [Wx::GraphicsMatrix]
-    # @overload create_matrix(mat)
-    #   Creates a native affine transformation matrix from the passed generic one.
-    #   @param mat [Wx::AffineMatrix2DBase] 
-    #   @return [Wx::GraphicsMatrix]
-    def create_matrix(*args) end
+    # Creates a native affine transformation matrix from the passed in values.
+    # The default parameters result in an identity matrix.
+    # @param a [Float] 
+    # @param b [Float] 
+    # @param c [Float] 
+    # @param d [Float] 
+    # @param tx [Float] 
+    # @param ty [Float] 
+    # @return [Wx::GraphicsMatrix]
+    def create_matrix(a=1.0, b=0.0, c=0.0, d=1.0, tx=0.0, ty=0.0) end
     
     # Concatenates the passed in transform with the current transform of this context.
     # @param matrix [Wx::GraphicsMatrix] 
@@ -413,15 +404,9 @@ module Wx
     # @return [void]
     def draw_icon(icon, x, y, w, h) end
     
-    # Draws a polygon.
-    # @param points [Array<Array<Float,Float>>] 
-    # @param fillStyle [PolygonFillMode] 
-    # @return [void]
-    def draw_lines(points, fillStyle=Wx::PolygonFillMode::ODDEVEN_RULE) end
-    
     # Draws the path by first filling and then stroking.
     # @param path [Wx::GraphicsPath] 
-    # @param fillStyle [PolygonFillMode] 
+    # @param fillStyle [Wx::PolygonFillMode] 
     # @return [void]
     def draw_path(path, fillStyle=Wx::PolygonFillMode::ODDEVEN_RULE) end
     
@@ -478,7 +463,7 @@ module Wx
     
     # Fills the path with the current brush.
     # @param path [Wx::GraphicsPath] 
-    # @param fillStyle [PolygonFillMode] 
+    # @param fillStyle [Wx::PolygonFillMode] 
     # @return [void]
     def fill_path(path, fillStyle=Wx::PolygonFillMode::ODDEVEN_RULE) end
     
@@ -490,17 +475,6 @@ module Wx
     # @return [void]
     def stroke_line(x1, y1, x2, y2) end
     
-    # @overload stroke_lines(n)
-    #   Stroke disconnected lines from begin to end points, fastest method available for this purpose.
-    #   @param n [Array<Array<Array<Float,Float>,Array<Float,Float>>>] 
-    #   @return [void]
-    # @overload stroke_lines(points)
-    #   Stroke lines connecting all the points.
-    #   Unlike the other overload of this function, this method draws a single polyline and not a number of disconnected lines.
-    #   @param points [Array<Array<Float,Float>>] 
-    #   @return [void]
-    def stroke_lines(*args) end
-    
     # Strokes along a path with the current pen.
     # @param path [Wx::GraphicsPath] 
     # @return [void]
@@ -538,9 +512,8 @@ module Wx
     
     # Fills the widths array with the widths from the beginning of text to the corresponding character of text.
     # @param text [String] 
-    # @param widths [Wx::ArrayDouble] 
-    # @return [void]
-    def get_partial_text_extents(text, widths) end
+    # @return [Array<Float>]
+    def get_partial_text_extents(text) end
     alias_method :partial_text_extents, :get_partial_text_extents
     
     # Gets the dimensions of the string using the currently selected font.
@@ -551,7 +524,7 @@ module Wx
     
     # Begin a new document (relevant only for printing / pdf etc.) If there is a progress dialog, message will be shown.
     # @param message [String] 
-    # @return [true,false]
+    # @return [Boolean]
     def start_doc(message) end
     
     # Done with that document (relevant only for printing / pdf etc.)
@@ -618,36 +591,36 @@ module Wx
     def flush; end
     
     # Sets the antialiasing mode, returns true if it supported.
-    # @param antialias [AntialiasMode] 
-    # @return [true,false]
+    # @param antialias [Wx::AntialiasMode] 
+    # @return [Boolean]
     def set_antialias_mode(antialias) end
     alias_method :antialias_mode=, :set_antialias_mode
     
     # Returns the current shape antialiasing mode.
-    # @return [AntialiasMode]
+    # @return [Wx::AntialiasMode]
     def get_antialias_mode; end
     alias_method :antialias_mode, :get_antialias_mode
     
     # Sets the interpolation quality, returns true if it is supported.
     # Not implemented in Cairo backend currently.
-    # @param interpolation [InterpolationQuality] 
-    # @return [true,false]
+    # @param interpolation [Wx::InterpolationQuality] 
+    # @return [Boolean]
     def set_interpolation_quality(interpolation) end
     alias_method :interpolation_quality=, :set_interpolation_quality
     
     # Returns the current interpolation quality.
-    # @return [InterpolationQuality]
+    # @return [Wx::InterpolationQuality]
     def get_interpolation_quality; end
     alias_method :interpolation_quality, :get_interpolation_quality
     
     # Sets the compositing operator, returns true if it supported.
-    # @param op [CompositionMode] 
-    # @return [true,false]
+    # @param op [Wx::CompositionMode] 
+    # @return [Boolean]
     def set_composition_mode(op) end
     alias_method :composition_mode=, :set_composition_mode
     
     # Returns the current compositing operator.
-    # @return [CompositionMode]
+    # @return [Wx::CompositionMode]
     def get_composition_mode; end
     alias_method :composition_mode, :get_composition_mode
     
@@ -657,10 +630,8 @@ module Wx
     alias_method :size, :get_size
     
     # Returns the resolution of the graphics context in device points per inch.
-    # @param dpiX [Float] 
-    # @param dpiY [Float] 
-    # @return [void]
-    def get_dpi(dpiX, dpiY) end
+    # @return [Array(Float,Float)]
+    def get_dpi; end
     alias_method :dpi, :get_dpi
     
     # Returns the associated window if any.
@@ -671,12 +642,12 @@ module Wx
     alias_method :window, :get_window
     
     # Helper to determine if a 0.5 offset should be applied for the drawing operation.
-    # @return [true,false]
+    # @return [Boolean]
     def should_offset; end
     
     # Indicates whether the context should try to offset for pixel boundaries.
     # This only makes sense on bitmap devices like screen. By default this is turned off.
-    # @param enable [true,false] 
+    # @param enable [Boolean] 
     # @return [void]
     def enable_offset(enable=true) end
     
@@ -685,7 +656,7 @@ module Wx
     def disable_offset; end
     
     # Helper to determine if a 0.5 offset should be applied for the drawing operation.
-    # @return [true,false]
+    # @return [Boolean]
     def offset_enabled; end
     
     # @overload from_dip(sz)
@@ -722,5 +693,265 @@ module Wx
     
   end # GraphicsContext
   
+  # Represents a single gradient stop in a collection of gradient stops as represented by {Wx::GraphicsGradientStops}.
+  # === 
+  # 
+  # Category:  Graphics Device Interface (GDI)
+  # 
+  # 
+  # @note This class is <b>untracked</b> and should not be derived from nor instances extended!
+  class GraphicsGradientStop < ::Object
+  
+    # Return the stop colour.
+    # @return [Wx::Colour,String,Symbol]
+    def get_colour; end
+    alias_method :colour, :get_colour
+    
+    # Change the stop colour.
+    # @param col [Wx::Colour,String,Symbol]  The new colour.
+    # @return [void]
+    def set_colour(col) end
+    alias_method :colour=, :set_colour
+    
+    # Return the stop position.
+    # @return [Float]
+    def get_position; end
+    alias_method :position, :get_position
+    
+    # Change the stop position.
+    # @param pos [Float]  The new position, must always be in [0, 1] range.
+    # @return [void]
+    def set_position(pos) end
+    alias_method :position=, :set_position
+    
+  end # GraphicsGradientStop
+  
+  # Represents a collection of {Wx::GraphicGradientStop} values for use with CreateLinearGradientBrush and CreateRadialGradientBrush.
+  # The stops are maintained in order of position. If two or more stops are added with the same position then the one(s) added later come later. This can be useful for producing discontinuities in the colour gradient.
+  # Notice that this class is write-once, you can't modify the stops once they had been added.
+  # === 
+  # 
+  # Category:  Graphics Device Interface (GDI)
+  # 
+  # 
+  # @note This class is <b>untracked</b> and should not be derived from nor instances extended!
+  class GraphicsGradientStops < ::Object
+  
+    # @overload add(stop)
+    #   Add a new stop.
+    #   @param stop [Wx::GraphicsGradientStop] 
+    #   @return [void]
+    # @overload add(col, pos)
+    #   Add a new stop.
+    #   @param col [Wx::Colour] 
+    #   @param pos [Float] 
+    #   @return [void]
+    def add(*args) end
+    
+    # Initializes the gradient stops with the given boundary colours.
+    # Creates a {Wx::GraphicsGradientStops} instance with start colour given by startCol and end colour given by endCol.
+    # @param startCol [Wx::Colour] 
+    # @param endCol [Wx::Colour] 
+    # @return [Wx::GraphicsGradientStops]
+    def initialize(startCol=Wx::TransparentColour, endCol=Wx::TransparentColour) end
+    
+    # Returns the stop at the given index.
+    # @param n [unsigned]  The index, must be in [0, {Wx::GraphicsGradientStops#get_count}) range.
+    # @return [Wx::GraphicsGradientStop]
+    def item(n) end
+    
+    # Returns the number of stops.
+    # @return [Integer]
+    def get_count; end
+    alias_method :count, :get_count
+    
+    # Set the start colour to col.
+    # @param col [Wx::Colour] 
+    # @return [void]
+    def set_start_colour(col) end
+    alias_method :start_colour=, :set_start_colour
+    
+    # Returns the start colour.
+    # @return [Wx::Colour]
+    def get_start_colour; end
+    alias_method :start_colour, :get_start_colour
+    
+    # Set the end colour to col.
+    # @param col [Wx::Colour] 
+    # @return [void]
+    def set_end_colour(col) end
+    alias_method :end_colour=, :set_end_colour
+    
+    # Returns the end colour.
+    # @return [Wx::Colour]
+    def get_end_colour; end
+    alias_method :end_colour, :get_end_colour
+    
+  end # GraphicsGradientStops
+  
+  # This class is a helper used for {Wx::GraphicsPen} creation using named parameter idiom: it allows specifying various {Wx::GraphicsPen} attributes using the chained calls to its clearly named methods instead of passing them in the fixed order to {Wx::GraphicsPen} constructors.
+  # Typically you would use {Wx::GraphicsPenInfo} with a {Wx::GraphicsContext}, e.g. to start drawing with a dotted blue pen slightly wider than normal you could write the following: 
+  # ```
+  #   wxGraphicsContext ctx = wxGraphicsContext::Create(dc);
+  #   
+  #   ctx.SetPen(wxGraphicsPenInfo(*wxBLUE).Width(1.25).Style(wxPENSTYLE_DOT));
+  # ```
+  # 
+  # 
+  # @note This class is <b>untracked</b> and should not be derived from nor instances extended!
+  class GraphicsPenInfo < ::Object
+  
+    # @param colour [Wx::Colour,String,Symbol] 
+    # @param width [Float] 
+    # @param style [Wx::PenStyle] 
+    # @return [Wx::GraphicsPenInfo]
+    def initialize(colour=(Wx::Colour.new()), width=1.0, style=Wx::PenStyle::PENSTYLE_SOLID) end
+    
+    # @param col [Wx::Colour,String,Symbol] 
+    # @return [Wx::GraphicsPenInfo]
+    def colour(col) end
+    
+    # @param width [Float] 
+    # @return [Wx::GraphicsPenInfo]
+    def width(width) end
+    
+    # @param style [Wx::PenStyle] 
+    # @return [Wx::GraphicsPenInfo]
+    def style(style) end
+    
+    # @param stipple [Wx::Bitmap] 
+    # @return [Wx::GraphicsPenInfo]
+    def stipple(stipple) end
+    
+    # @param nb_dashes [Integer] 
+    # @param dash [Wx::Dash] 
+    # @return [Wx::GraphicsPenInfo]
+    def dashes(nb_dashes, dash) end
+    
+    # @param join [Wx::PenJoin] 
+    # @return [Wx::GraphicsPenInfo]
+    def join(join) end
+    
+    # @param cap [Wx::PenCap] 
+    # @return [Wx::GraphicsPenInfo]
+    def cap(cap) end
+    
+    # @overload linear_gradient(x1, y1, x2, y2, c1, c2, matrix=Wx::NULL_GRAPHICS_MATRIX)
+    #   @param x1 [Float] 
+    #   @param y1 [Float] 
+    #   @param x2 [Float] 
+    #   @param y2 [Float] 
+    #   @param c1 [Wx::Colour,String,Symbol] 
+    #   @param c2 [Wx::Colour,String,Symbol] 
+    #   @param matrix [Wx::GraphicsMatrix] 
+    #   @return [Wx::GraphicsPenInfo]
+    # @overload linear_gradient(x1, y1, x2, y2, stops, matrix=Wx::NULL_GRAPHICS_MATRIX)
+    #   @param x1 [Float] 
+    #   @param y1 [Float] 
+    #   @param x2 [Float] 
+    #   @param y2 [Float] 
+    #   @param stops [Wx::GraphicsGradientStops] 
+    #   @param matrix [Wx::GraphicsMatrix] 
+    #   @return [Wx::GraphicsPenInfo]
+    def linear_gradient(*args) end
+    
+    # @overload radial_gradient(startX, startY, endX, endY, radius, oColor, cColor, matrix=Wx::NULL_GRAPHICS_MATRIX)
+    #   @param startX [Float] 
+    #   @param startY [Float] 
+    #   @param endX [Float] 
+    #   @param endY [Float] 
+    #   @param radius [Float] 
+    #   @param oColor [Wx::Colour,String,Symbol] 
+    #   @param cColor [Wx::Colour,String,Symbol] 
+    #   @param matrix [Wx::GraphicsMatrix] 
+    #   @return [Wx::GraphicsPenInfo]
+    # @overload radial_gradient(startX, startY, endX, endY, radius, stops, matrix=Wx::NULL_GRAPHICS_MATRIX)
+    #   @param startX [Float] 
+    #   @param startY [Float] 
+    #   @param endX [Float] 
+    #   @param endY [Float] 
+    #   @param radius [Float] 
+    #   @param stops [Wx::GraphicsGradientStops] 
+    #   @param matrix [Wx::GraphicsMatrix] 
+    #   @return [Wx::GraphicsPenInfo]
+    def radial_gradient(*args) end
+    
+    # @return [Wx::Colour]
+    def get_colour; end
+    
+    # @return [Wx::Bitmap]
+    def get_stipple; end
+    
+    # @return [Wx::PenStyle]
+    def get_style; end
+    
+    # @return [Wx::PenJoin]
+    def get_join; end
+    
+    # @return [Wx::PenCap]
+    def get_cap; end
+    
+    # @param ptr [Wx::Dash] 
+    # @return [Integer]
+    def get_dashes(ptr) end
+    alias_method :dashes, :get_dashes
+    
+    # @return [Integer]
+    def get_dash_count; end
+    alias_method :dash_count, :get_dash_count
+    
+    # @return [Boolean]
+    def is_transparent; end
+    alias_method :transparent?, :is_transparent
+    
+    # @return [Float]
+    def get_width; end
+    
+    # @return [Wx::GradientType]
+    def get_gradient_type; end
+    alias_method :gradient_type, :get_gradient_type
+    
+    # @return [Float]
+    def get_x1; end
+    alias_method :x1, :get_x1
+    
+    # @return [Float]
+    def get_y1; end
+    alias_method :y1, :get_y1
+    
+    # @return [Float]
+    def get_x2; end
+    alias_method :x2, :get_x2
+    
+    # @return [Float]
+    def get_y2; end
+    alias_method :y2, :get_y2
+    
+    # @return [Float]
+    def get_start_x; end
+    alias_method :start_x, :get_start_x
+    
+    # @return [Float]
+    def get_start_y; end
+    alias_method :start_y, :get_start_y
+    
+    # @return [Float]
+    def get_end_x; end
+    alias_method :end_x, :get_end_x
+    
+    # @return [Float]
+    def get_end_y; end
+    alias_method :end_y, :get_end_y
+    
+    # @return [Float]
+    def get_radius; end
+    alias_method :radius, :get_radius
+    
+    # @return [Wx::GraphicsGradientStops]
+    def get_stops; end
+    alias_method :stops, :get_stops
+    
+  end # GraphicsPenInfo
+  
 
 end

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

@@ -177,7 +177,7 @@ module Wx
   
     # 
     # false if this object is valid, otherwise returns true.
-    # @return [true,false]
+    # @return [Boolean]
     def is_null; end
     alias_method :null?, :is_null
     
@@ -211,32 +211,19 @@ module Wx
   # 
   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.
+    # 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 [Boolean] 
+    # @return [void]
+    def add_arc(x, y, r, startAngle, endAngle, clockwise) 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.
@@ -256,24 +243,16 @@ module Wx
     # @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
+    # 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]
+    def add_curve_to_point(cx1, cy1, cx2, cy2, x, y) 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).
@@ -284,18 +263,12 @@ module Wx
     # @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 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]
+    def add_line_to_point(x, y) 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.
@@ -336,47 +309,24 @@ module Wx
     # @return [void]
     def close_subpath; end
     
-    # @overload contains(c, fillStyle=Wx::PolygonFillMode::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::PolygonFillMode::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).
+    # 
+    # true if the point is within the path.
     # @param x [Float] 
     # @param y [Float] 
-    # @param w [Float] 
-    # @param h [Float] 
-    # @return [void]
-    def get_box(x, y, w, h) end
+    # @param fillStyle [Wx::PolygonFillMode] 
+    # @return [Boolean]
+    def contains(x, y, fillStyle=Wx::PolygonFillMode::ODDEVEN_RULE) end
+    
+    # Gets the bounding box enclosing all points (possibly including control points).
+    # @return [Array(Float,Float,Float,Float)]
+    def get_box; end
     alias_method :box, :get_box
     
-    # Gets the last point of the current path, (0,0) if not yet set.
+    # Begins a new subpath at (x,y).
     # @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
+    def move_to_point(x, y) 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.
@@ -424,12 +374,12 @@ module Wx
     
     # Returns true if the elements of the transformation matrix are equal.
     # @param t [Wx::GraphicsMatrix] 
-    # @return [true,false]
+    # @return [Boolean]
     def is_equal(t) end
     alias_method :equal?, :is_equal
     
     # Return true if this is the identity matrix.
-    # @return [true,false]
+    # @return [Boolean]
     def is_identity; end
     alias_method :identity?, :is_identity
     
@@ -456,16 +406,12 @@ module Wx
     
     # 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
+    # @return [Array(Float,Float)]
+    def transform_distance; end
     
     # Applies this matrix to a point.
-    # @param x [Float] 
-    # @param y [Float] 
-    # @return [void]
-    def transform_point(x, y) end
+    # @return [Array(Float,Float)]
+    def transform_point; end
     
     # Translates this matrix.
     # @param dx [Float] 

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

@@ -9,6 +9,8 @@ module Wx::GRID
   # Base class for activatable editors.
   # Inheriting from this class makes it simpler to implement editors that support only activation, but not in-place editing, as they only need to implement {Wx::GRID::GridCellActivatableEditor#try_activate}, {Wx::GRID::GridCellActivatableEditor#do_activate} and {Wx::GRID::GridCellActivatableEditor#clone} methods, but not all the other pure virtual methods of {Wx::GRID::GridCellEditor}.
   # 
+  # 
+  # @note This class is <b>untracked</b> and should not be derived from nor instances extended!
   class GridCellActivatableEditor < GridCellEditor
   
     # Same method as in {Wx::GRID::GridCellEditor}, but pure virtual.