wxruby3 1.6.1 → 1.7.0

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

@@ -0,0 +1,750 @@
+# :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}.
+  # 
+  # 
+  # 
+  # @wxrb_require USE_GRAPHICS_CONTEXT
+  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}.
+  # 
+  # 
+  # 
+  # @wxrb_require USE_GRAPHICS_CONTEXT
+  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 gives 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
+  # 
+  # @wxrb_require USE_GRAPHICS_CONTEXT
+  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.
+  # 
+  # 
+  # 
+  # @wxrb_require USE_GRAPHICS_CONTEXT
+  class GradientType < Wx::Enum
+  
+    # No gradient.
+    # 
+    GRADIENT_NONE = Wx::GradientType.new(0)
+    
+    # A gradient that blends two or more colors along an axis.
+    # 
+    GRADIENT_LINEAR = Wx::GradientType.new(1)
+    
+    # A gradient that blends two or more colors across an ellipse.
+    # 
+    GRADIENT_RADIAL = Wx::GradientType.new(2)
+    
+  end # GradientType
+  
+  # An empty {Wx::GraphicsPen} object.
+  # 
+  NULL_GRAPHICS_PEN = nil
+  
+  # An empty {Wx::GraphicsBrush} object.
+  # 
+  NULL_GRAPHICS_BRUSH = nil
+  
+  # An empty {Wx::GraphicsFont} object.
+  # 
+  NULL_GRAPHICS_FONT = nil
+  
+  # An empty {Wx::GraphicsBitmap} object.
+  # 
+  NULL_GRAPHICS_BITMAP = nil
+  
+  # An empty {Wx::GraphicsMatrix} object.
+  # 
+  NULL_GRAPHICS_MATRIX = nil
+  
+  # An empty {Wx::GraphicsPath} object.
+  # 
+  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 
+  # 
+  # 
+  # @wxrb_require USE_GRAPHICS_CONTEXT
+  class GraphicsObject < Object
+  
+    # Returns the renderer that was used to create this instance, or nil if it has not been initialized yet.
+    # @return [Wx::GraphicsRenderer]
+    def get_renderer; end
+    alias_method :renderer, :get_renderer
+    
+    # 
+    # 
+    # false if this object is valid; otherwise, returns true.
+    # @return [Boolean]
+    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)
+  # 
+  # @wxrb_require USE_GRAPHICS_CONTEXT
+  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)
+  # 
+  # @wxrb_require USE_GRAPHICS_CONTEXT
+  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)
+  # 
+  # @wxrb_require USE_GRAPHICS_CONTEXT
+  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 clockwise and arc endAngle is less than startAngle, it will be progressively increased by 2*pi until it is greater than startAngle. If counter-clockwise and 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]
+    # @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 clockwise and arc endAngle is less than startAngle, it will be progressively increased by 2*pi until it is greater than startAngle. If counter-clockwise and 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 [Wx::Point2DDouble] 
+    #   @param r [Float] 
+    #   @param startAngle [Float] 
+    #   @param endAngle [Float] 
+    #   @param clockwise [Boolean] 
+    #   @return [void]
+    def add_arc(*args) end
+    
+    # Adds an arc (of a circle with radius r) that is tangent to the line connecting the 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, then 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}, then 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 Bézier 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}, then this function will behave as if preceded by a call to MoveToPoint(cx1, cy1).
+    #   This is useful for pulling a section of a path in two directions, providing a smoother bump (or wave) in its appearance compared to a quadratic Bézier curve.
+    #   @param cx1 [Float]  The x coordinate of the first control point.
+    #   @param cy1 [Float]  The y coordinate of the first control point.
+    #   @param cx2 [Float]  The x coordinate of the second control point.
+    #   @param cy2 [Float]  The y coordinate of the second control point.
+    #   @param x [Float]  The x coordinate of the end point.
+    #   @param y [Float]  The y coordinate of the end point.
+    #   @return [void]
+    # @overload add_curve_to_point(c1, c2, e)
+    #   Adds a cubic Bézier 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}, then this function will behave as if preceded by a call to MoveToPoint(c1).
+    #   This is useful for pulling a section of a path in two directions, providing a smoother bump (or wave) in its appearance compared to a quadratic Bézier curve.
+    #   @param c1 [Wx::Point2DDouble]  The first control point.
+    #   @param c2 [Wx::Point2DDouble]  The second control point.
+    #   @param e [Wx::Point2DDouble]  The end point.
+    #   @return [void]
+    def add_curve_to_point(*args) end
+    
+    # @overload add_ellipse(x, y, w, h)
+    #   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]
+    # @overload add_ellipse(rect)
+    #   This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
+    #   @param rect [Wx::Rect2DDouble] 
+    #   @return [void]
+    def add_ellipse(*args) 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}, then 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}, then this function will behave as {Wx::GraphicsPath#move_to_point}.
+    #   @param p [Wx::Point2DDouble] 
+    #   @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
+    
+    # @overload add_quad_curve_to_point(cx, cy, x, y)
+    #   Adds a quadratic Bézier 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}, then this function will behave as if preceded by a call to MoveToPoint(cx, cy).
+    #   This is useful for pulling a section of a path in one direction, providing a sharper bump in its appearance compared to a cubic Bézier curve.
+    #   @param cx [Float]  The x coordinate of the control point.
+    #   @param cy [Float]  The y coordinate of the control point.
+    #   @param x [Float]  The x coordinate of the end point.
+    #   @param y [Float]  The y coordinate of the end point.
+    #   @return [void]
+    # @overload add_quad_curve_to_point(cp, e)
+    #   This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
+    #   @param cp [Wx::Point2DDouble] 
+    #   @param e [Wx::Point2DDouble] 
+    #   @return [void]
+    def add_quad_curve_to_point(*args) end
+    
+    # @overload add_rectangle(x, y, w, h)
+    #   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]
+    # @overload add_rectangle(rect)
+    #   This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
+    #   @param rect [Wx::Rect2DDouble] 
+    #   @return [void]
+    def add_rectangle(*args) end
+    
+    # @overload add_rounded_rectangle(x, y, w, h, radius)
+    #   Appends a rounded rectangle as a new closed subpath.
+    #   
+    #   If radius equals 0, then 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]
+    # @overload add_rounded_rectangle(rect, radius)
+    #   This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
+    #   @param rect [Wx::Rect2DDouble] 
+    #   @param radius [Float] 
+    #   @return [void]
+    def add_rounded_rectangle(*args) end
+    
+    # Closes the current sub-path.
+    # 
+    # After this call, the current point will be at the joined end point of the sub-path.
+    # @return [void]
+    def close_subpath; end
+    
+    # @overload contains(c, fillStyle=Wx::PolygonFillMode::ODDEVEN_RULE)
+    #   
+    #   
+    #   true if the point is within the path.
+    #   @param c [Wx::Point2DDouble] 
+    #   @param fillStyle [Wx::PolygonFillMode] 
+    #   @return [Boolean]
+    # @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 [Wx::PolygonFillMode] 
+    #   @return [Boolean]
+    def contains(*args) end
+    
+    # Gets the bounding box enclosing all points (possibly including control points).
+    # @return [Wx::Rect2DDouble]
+    def get_box; end
+    alias_method :box, :get_box
+    
+    # Gets the last point of the current path, (0,0) if not yet set.
+    # @return [Wx::Point2DDouble]
+    def get_current_point; 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 [Wx::Point2DDouble] 
+    #   @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)
+  # 
+  # @wxrb_require USE_GRAPHICS_CONTEXT
+  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)
+  # 
+  # @wxrb_require USE_GRAPHICS_CONTEXT
+  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 [Boolean]
+    def is_equal(t) end
+    alias_method :equal?, :is_equal
+    
+    # Return true if this is the identity matrix.
+    # @return [Boolean]
+    def is_identity; end
+    alias_method :identity?, :is_identity
+    
+    # Rotates this matrix clockwise (in radians).
+    # 
+    # This can be useful for applying a tilt to your drawing commands or for drawing radial patterns.
+    # @see deg_to_rad 
+    # @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
+    
+    # @overload translate(dx, dy)
+    #   Translates this matrix.
+    #   @param dx [Float] 
+    #   @param dy [Float] 
+    #   @return [void]
+    # @overload translate(pt)
+    #   This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
+    #   @param pt [Wx::Point2DDouble] 
+    #   @return [void]
+    def translate(*args) 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} inherited from the base class.
+  # 
+  # @wxrb_require USE_GRAPHICS_CONTEXT
+  class GraphicsBitmap < GraphicsObject
+  
+    # Default constructor creates an invalid bitmap.
+    # @return [Wx::GraphicsBitmap]
+    def initialize; end
+    
+    # Return the contents of this bitmap as a {Wx::Image}.
+    # 
+    # Using this method is more efficient than converting a {Wx::GraphicsBitmap} to a {Wx::Bitmap} first and then to a {Wx::Image}. This can be useful if, for example, you want to save a {Wx::GraphicsBitmap} in a file 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
+  
+  # A {Wx::GraphicsRenderer} is the instance corresponding to the rendering engine used.
+  # 
+  # There may be multiple instances on a system, if there are different rendering engines present, but there is always only one instance per engine. This instance is pointed back to by all objects created by it ({Wx::GraphicsContext}, {Wx::GraphicsPath}, etc.) and can be retrieved through their {Wx::GraphicsObject#get_renderer} method. Therefore, you can create an additional instance of a path (or other objects) by calling {Wx::GraphicsObject#get_renderer} and then using the appropriate CreateXXX() function of that renderer.
+  # 
+  # ```ruby
+  #   # path = Wx::GraphicsPath from somewhere
+  #   brush = path.get_renderer.create_brush(Wx::BLACK_BRUSH)
+  # ```
+  # 
+  # Category:  Graphics Device Interface (GDI)
+  # 
+  # @wxrb_require USE_GRAPHICS_CONTEXT
+  class GraphicsRenderer < Object
+  
+    # Creates {Wx::GraphicsBitmap} from an existing {Wx::Bitmap}.
+    # 
+    # An invalid {Wx::NULL_GRAPHICS_BITMAP} on failure.
+    # @param bitmap [Wx::Bitmap] 
+    # @return [Wx::GraphicsBitmap]
+    def create_bitmap(bitmap) end
+    
+    # Creates {Wx::GraphicsBitmap} from an existing {Wx::Image}.
+    # 
+    # This method is more efficient than converting a {Wx::Image} to a {Wx::Bitmap} first and then calling {Wx::GraphicsRenderer#create_bitmap}, but otherwise has the same effect.
+    # An invalid {Wx::NULL_GRAPHICS_BITMAP} on failure.
+    # @param image [Wx::Image] 
+    # @return [Wx::GraphicsBitmap]
+    def create_bitmap_from_image(image) end
+    
+    # Creates a {Wx::Image} from a {Wx::GraphicsBitmap}.
+    # 
+    # This method is used by the more convenient {Wx::GraphicsBitmap#convert_to_image}.
+    # @param bmp [Wx::GraphicsBitmap] 
+    # @return [Wx::Image]
+    def create_image_from_bitmap(bmp) end
+    
+    # @overload create_context(window)
+    #   Creates a {Wx::GraphicsContext} from a {Wx::Window}.
+    #   @param window [Wx::Window] 
+    #   @return [Wx::GraphicsContext]
+    # @overload create_context(windowDC)
+    #   Creates a {Wx::GraphicsContext} from a {Wx::WindowDC}.
+    #   @param windowDC [Wx::WindowDC] 
+    #   @return [Wx::GraphicsContext]
+    # @overload create_context(memoryDC)
+    #   Creates a {Wx::GraphicsContext} from a {Wx::MemoryDC}.
+    #   @param memoryDC [Wx::MemoryDC] 
+    #   @return [Wx::GraphicsContext]
+    # @overload create_context(printerDC)
+    #   Creates a {Wx::GraphicsContext} from a {Wx::PRT::PrinterDC}.
+    #   
+    #   <div class="wxrb-remark">
+    #   <b>Remark:</b>
+    #   <p>Not implemented for the Direct2D renderer (on MSW). 
+    #   </p>
+    #   </div>
+    #   @param printerDC [Wx::PRT::PrinterDC] 
+    #   @return [Wx::GraphicsContext]
+    def create_context(*args) end
+    
+    # Creates a {Wx::GraphicsContext} from a DC of unknown specific type.
+    # 
+    # Creates a {Wx::GraphicsContext} if dc is a supported type (i.e. has a corresponding {Wx::GraphicsRenderer#create_context} method, e.g. {Wx::WindowDC} or {Wx::MemoryDC}).
+    # This method is only useful as a helper in generic code that operates with {Wx::DC} and doesn't known its exact type. Use the appropriate {Wx::GraphicsRenderer#create_context} overload instead if you know what the DC is (e.g., {Wx::WindowDC}).
+    # nil if the DC is unsupported.
+    # @see Wx::GraphicsContext.create_from_unknown_dc
+    # @param dc [Wx::DC] 
+    # @return [Wx::GraphicsContext]
+    def create_context_from_unknown_dc(dc) end
+    
+    # Creates a {Wx::GraphicsContext} associated with a {Wx::Image}.
+    # 
+    # This function is used by Wx::Context#create_from_image and is not normally called directly.
+    # @param image [Wx::Image] 
+    # @return [Wx::GraphicsContext]
+    def create_context_from_image(image) end
+    
+    # Creates a native brush from a {Wx::Brush}.
+    # @param brush [Wx::Brush] 
+    # @return [Wx::GraphicsBrush]
+    def create_brush(brush) end
+    
+    # Creates a {Wx::GraphicsContext} that can be used for measuring texts only.
+    # 
+    # No drawing commands are allowed.
+    # @return [Wx::GraphicsContext]
+    def create_measuring_context; end
+    
+    # @overload create_font(font, col=Wx::BLACK)
+    #   Creates a native graphics font from a {Wx::Font} and a text colour.
+    #   @param font [Wx::Font,Wx::FontInfo] 
+    #   @param col [Wx::Colour,String,Symbol] 
+    #   @return [Wx::GraphicsFont]
+    # @overload create_font(sizeInPixels, facename, flags=Wx::FontFlag::FONTFLAG_DEFAULT, col=Wx::BLACK)
+    #   Creates a graphics font with the given characteristics.
+    #   
+    #   If possible, the {Wx::GraphicsRenderer#create_font} overload taking {Wx::Font} should be used instead. The main advantage of this overload is that it can be used without X server connection under Unix when using Cairo.
+    #   @param sizeInPixels [Float]  Height of the font in user space units (normally pixels). Notice that this is different from the overload taking {Wx::Font} as {Wx::Font}'s size is specified in points.
+    #   @param facename [String]  The name of the font. The same font name might not be available under all platforms so the font name can also be empty to use the default platform font.
+    #   @param flags [Integer]  Combination of {Wx::FontFlag} enum elements. Currently only {Wx::FontFlag::FONTFLAG_ITALIC} and {Wx::FontFlag::FONTFLAG_BOLD} are supported. By default, the normal font version is used.
+    #   @param col [Wx::Colour,String,Symbol]  The font colour, black by default.
+    #   @return [Wx::GraphicsFont]
+    def create_font(*args) end
+    
+    # Creates a native graphics font from a {Wx::Font} and a text colour.
+    # 
+    # The specified DPI is used to convert the (fractional) {Wx::Font} point-size to a fractional pixel-size.
+    # @param font [Wx::Font,Wx::FontInfo] 
+    # @param dpi [Wx::RealPoint] 
+    # @param col [Wx::Colour,String,Symbol] 
+    # @return [Wx::GraphicsFont]
+    def create_font_at_dpi(font, dpi, col=Wx::BLACK) end
+    
+    # Creates a native brush with a linear gradient.
+    # 
+    # Stops support is new since wxWidgets 2.9.1; previously, only the start and end colours could be specified.
+    # The ability to apply a transformation matrix to the gradient was added in 3.1.3.
+    # @param x1 [Float] 
+    # @param y1 [Float] 
+    # @param x2 [Float] 
+    # @param y2 [Float] 
+    # @param stops [Wx::GraphicsGradientStops] 
+    # @param matrix [Wx::GraphicsMatrix] 
+    # @return [Wx::GraphicsBrush]
+    def create_linear_gradient_brush(x1, y1, x2, y2, stops, matrix=Wx::NULL_GRAPHICS_MATRIX) end
+    
+    # Creates a native affine transformation matrix from the passed in values.
+    # 
+    # The defaults 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
+    
+    # Creates a native graphics path which is initially empty.
+    # @return [Wx::GraphicsPath]
+    def create_path; end
+    
+    # Creates a native pen from its description.
+    # @param info [Wx::GraphicsPenInfo] 
+    # @return [Wx::GraphicsPen]
+    def create_pen(info) end
+    
+    # Creates a native brush with a radial gradient.
+    # 
+    # Stops support is new since wxWidgets 2.9.1; previously, only the start and end colours could be specified.
+    # The ability to apply a transformation matrix to the gradient was added in 3.1.3.
+    # @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::GraphicsBrush]
+    def create_radial_gradient_brush(startX, startY, endX, endY, radius, stops, matrix=Wx::NULL_GRAPHICS_MATRIX) end
+    
+    # Extracts a sub-bitmap from an existing bitmap.
+    # @param bitmap [Wx::GraphicsBitmap] 
+    # @param x [Float] 
+    # @param y [Float] 
+    # @param w [Float] 
+    # @param h [Float] 
+    # @return [Wx::GraphicsBitmap]
+    def create_sub_bitmap(bitmap, x, y, w, h) end
+    
+    # Returns the name of the technology used by the renderer.
+    # 
+    # Currently, this function returns "gdiplus" for the Windows GDI+ implementation, "direct2d" for Windows Direct2D, "cairo" for Cairo and "cg" for macOS CoreGraphics.
+    # 
+    # <div class="wxrb-remark">
+    # <b>Remark:</b>
+    # <p>The string returned by this method is not user-readable and is expected to be used internally by the program only.
+    # </p>
+    # </div>
+    # @return [String]
+    def get_name; end
+    alias_method :name, :get_name
+    
+    # Returns the version major, minor and micro/build of the technology used by the renderer.
+    # 
+    # Currently, this function returns the OS major and minor versions in the parameters with the matching names and sets micro to 0 for the GDI+ and CoreGraphics engines, which are considered to be parts of their respective OS.
+    # For Cairo, this is the major,minor,micro version of the Cairo library which is returned.
+    # @return [Array(Integer,Integer,Integer)]
+    def get_version; end
+    alias_method :version, :get_version
+    
+    # Returns the default renderer on this platform.
+    # 
+    # On macOS, this is the Core Graphics (a.k.a. Quartz 2D) renderer, on MSW the GDI+ renderer, and on GTK we currently default to the Cairo renderer.
+    # @return [Wx::GraphicsRenderer]
+    def self.get_default_renderer; end
+    
+    # Returns the Cairo renderer.
+    # @return [Wx::GraphicsRenderer]
+    def self.get_cairo_renderer; end
+    
+  end # GraphicsRenderer
+  
+
+end