wxruby3 1.6.1 → 1.7.0

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

@@ -0,0 +1,1184 @@
+# :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
+  
+  # A {Wx::GraphicsContext} instance is the object that is drawn upon.
+  # 
+  # It is created by a renderer using {Wx::GraphicsRenderer#create_context}. This can be either directly using a renderer instance, or indirectly using the static convenience {Wx::GraphicsContext.create} functions of {Wx::GraphicsContext} that always delegate the task to the default renderer.
+  # 
+  # ```ruby
+  #   class MyCanvas < Wx::ScrolledWindow
+  # 
+  #     def on_paint(event)
+  #        # Create paint DC
+  #        self.paint do |dc|
+  #          # Create graphics context from it
+  #          Wx::GraphicsContext.draw_on(dc) do |gc|
+  #              # make a path that contains a circle and some lines
+  #              gc.set_pen(Wx::RED_PEN)
+  #              path = gc.create_path
+  #              path.add_circle(50.0, 50.0, 50.0)
+  #              path.move_to_point(0.0, 50.0)
+  #              path.add_line_to_point(100.0, 50.0)
+  #              path.move_to_point(50.0, 0.0)
+  #              path.add_line_to_point(50.0, 100.0)
+  #              path.close_sub_path
+  #              path.add_rectangle(25.0, 25.0, 50.0, 50.0)
+  #       
+  #              gc.stroke_path(path)
+  #           end
+  #         end
+  #       end
+  #     end
+  #   end
+  # ```
+  # 
+  # <div class="wxrb-remark">
+  # <b>Remark:</b>
+  # <p>For some renderers (like Direct2D or Cairo), the processing of drawing operations may be deferred. For example, Direct2D render targets normally build up a batch of rendering commands but defers processing them, while Cairo operates on a separate surface. To make drawing results visible, you need to update the context's content by either calling {Wx::GraphicsContext#flush} or by destroying the context.
+  # </p>
+  # </div>
+  # 
+  # Category:  Graphics Device Interface (GDI), Device Contexts
+  # @see Wx::GraphicsRenderer#create_context
+  # @see  Wx::GCDC
+  # @see  Wx::DC 
+  # 
+  # 
+  # 
+  # @note This class is <b>untracked</b> and should not be derived from nor instances extended!
+  # @wxrb_require USE_GRAPHICS_CONTEXT
+  class GraphicsContext < GraphicsObject
+  
+    # @overload self.create(window)
+    #   Creates a {Wx::GraphicsContext} from a {Wx::Window}.
+    #   
+    #   
+    #   @see Wx::GraphicsRenderer#create_context 
+    #   @param window [Wx::Window] 
+    #   @return [Wx::GraphicsContext]
+    # @overload self.create(windowDC)
+    #   Creates a {Wx::GraphicsContext} from a {Wx::WindowDC}.
+    #   
+    #   
+    #   @see Wx::GraphicsRenderer#create_context 
+    #   @param windowDC [Wx::WindowDC] 
+    #   @return [Wx::GraphicsContext]
+    # @overload self.create(memoryDC)
+    #   Creates a {Wx::GraphicsContext} from a {Wx::MemoryDC}.
+    #   
+    #   
+    #   @see Wx::GraphicsRenderer#create_context 
+    #   @param memoryDC [Wx::MemoryDC] 
+    #   @return [Wx::GraphicsContext]
+    # @overload self.create(printerDC)
+    #   Creates a {Wx::GraphicsContext} from a {Wx::PRT::PrinterDC}.
+    #   
+    #   Under GTK+, this will only work when using the GtkPrint printing backend (which is available since GTK+ 2.10).
+    #   @see Wx::GraphicsRenderer#create_context
+    #   @see  Printing Under Unix (GTK+) 
+    #   @param printerDC [Wx::PRT::PrinterDC] 
+    #   @return [Wx::GraphicsContext]
+    #   @wxrb_require WXMSW|WXOSX|USE_GTKPRINT
+    # @overload self.create(image)
+    #   Creates a {Wx::GraphicsContext} associated with a {Wx::Image}.
+    #   
+    #   The image specifies the size of the context, as well as whether alpha is supported (if {Wx::Image#has_alpha}) or not and the initial contents of the context. The image object must have a life time greater than that of the new context as the context copies its contents back to the image when it is destroyed.
+    #   @param image [Wx::Image] 
+    #   @return [Wx::GraphicsContext]
+    # @overload self.create()
+    #   Create a lightweight context that can be used only for measuring text.
+    #   @return [Wx::GraphicsContext]
+    def self.create(*args) end
+    
+    # Resets the clipping to original shape.
+    # 
+    # <div class="wxrb-remark">
+    # <b>Remark:</b>
+    # <p>Use {Wx::GraphicsContext#get_clip_box} to cache and restore a previous clipping area. 
+    # </p>
+    # </div>
+    # @return [void]
+    def reset_clip; end
+    
+    # @overload clip(region)
+    #   Sets the clipping region to the intersection of the given region and the previously set clipping region.
+    #   
+    #   The clipping region is an area to which drawing is restricted.
+    #   
+    #   <div class="wxrb-remark">
+    #   <b>Remark:</b>
+    #   <p>
+    #   
+    #   - Clipping region should be given in logical coordinates.
+    #   - Calling this function can only make the clipping region smaller, never larger.
+    #   - You need to call {Wx::GraphicsContext#reset_clip} first if you want to set the clipping region exactly to the region specified.
+    #   - If resulting clipping region is empty, then all drawing upon the context is clipped out (all changes made by drawing operations are masked out). 
+    #   
+    #   </p>
+    #   </div>
+    #   @param region [Wx::Region] 
+    #   @return [void]
+    # @overload clip(x, y, w, h)
+    #   This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
+    #   @param x [Float] 
+    #   @param y [Float] 
+    #   @param w [Float] 
+    #   @param h [Float] 
+    #   @return [void]
+    # @overload clip(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 clip(*args) end
+    
+    # This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
+    # @return [Wx::Rect2DDouble]
+    def get_clip_box; end
+    alias_method :clip_box, :get_clip_box
+    
+    # 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] 
+    # @return [void]
+    def concat_transform(matrix) end
+    
+    # Gets the current transformation matrix of this context.
+    # @return [Wx::GraphicsMatrix]
+    def get_transform; end
+    alias_method :transform, :get_transform
+    
+    # Rotates the current transformation matrix (in radians).
+    # 
+    # This can be useful for applying a tilt to your drawing commands or for drawing radial patterns.
+    # 
+    # <div class="wxrb-note">
+    # <b>Note:</b>
+    # <p>A positive angle will rotate clockwise, negative counterclockwise.
+    # </p>
+    # </div>
+    # @see deg_to_rad 
+    # @param angle [Float]  Rotation angle in radians, clockwise.
+    # @return [void]
+    def rotate(angle) end
+    
+    # Scales (i.e., shrinks or grows) the current transformation matrix.
+    # @param xScale [Float] 
+    # @param yScale [Float] 
+    # @return [void]
+    def scale(xScale, yScale) end
+    
+    # Sets the current transformation matrix of this context.
+    # @param matrix [Wx::GraphicsMatrix] 
+    # @return [void]
+    def set_transform(matrix) end
+    alias_method :transform=, :set_transform
+    
+    # @overload translate(dx, dy)
+    #   Translates (i.e., moves) the current transformation 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
+    
+    # Creates a native brush from a {Wx::Brush}.
+    # @param brush [Wx::Brush] 
+    # @return [Wx::GraphicsBrush]
+    def create_brush(brush) end
+    
+    # @overload create_linear_gradient_brush(x1, y1, x2, y2, c1, c2, matrix=Wx::NULL_GRAPHICS_MATRIX)
+    #   Creates a native brush with a linear gradient.
+    #   
+    #   The brush starts at (x1, y1) and ends at (x2, y2). Either just the start and end gradient colours (c1 and c2) or full set of gradient stops can be specified.
+    #   The version taking {Wx::GraphicsGradientStops} is new in wxWidgets 2.9.1.
+    #   The matrix parameter was added in wxWidgets 3.1.3.
+    #   @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::GraphicsBrush]
+    # @overload create_linear_gradient_brush(x1, y1, x2, y2, stops, matrix=Wx::NULL_GRAPHICS_MATRIX)
+    #   This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
+    #   @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(*args) end
+    
+    # @overload create_radial_gradient_brush(startX, startY, endX, endY, radius, oColor, cColor, matrix=Wx::NULL_GRAPHICS_MATRIX)
+    #   Creates a native brush with a radial gradient.
+    #   
+    #   The brush originates at (startX, startY) and ends on a circle around (endX, endY) with the given radius.
+    #   The gradient may be specified either by its start and end colours, oColor and cColor, or by a full set of gradient stops.
+    #   The version taking {Wx::GraphicsGradientStops} is new in wxWidgets 2.9.1.
+    #   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 oColor [Wx::Colour,String,Symbol] 
+    #   @param cColor [Wx::Colour,String,Symbol] 
+    #   @param matrix [Wx::GraphicsMatrix] 
+    #   @return [Wx::GraphicsBrush]
+    # @overload create_radial_gradient_brush(startX, startY, endX, endY, radius, stops, matrix=Wx::NULL_GRAPHICS_MATRIX)
+    #   This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
+    #   @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(*args) end
+    
+    # @overload set_brush(brush)
+    #   Sets the brush for filling paths.
+    #   @param brush [Wx::Brush] 
+    #   @return [void]
+    # @overload set_brush(brush)
+    #   Sets the brush for filling paths.
+    #   @param brush [Wx::GraphicsBrush] 
+    #   @return [void]
+    def set_brush(*args) end
+    alias_method :brush=, :set_brush
+    
+    # @overload create_pen(pen)
+    #   Creates a native pen from a {Wx::Pen}.
+    #   
+    #   Prefer to use the overload taking {Wx::GraphicsPenInfo} unless you already have a {Wx::Pen} as constructing one only to pass it to this method is wasteful.
+    #   @param pen [Wx::Pen] 
+    #   @return [Wx::GraphicsPen]
+    # @overload create_pen(info)
+    #   Creates a native pen from a {Wx::GraphicsPenInfo}.
+    #   @param info [Wx::GraphicsPenInfo] 
+    #   @return [Wx::GraphicsPen]
+    def create_pen(*args) end
+    
+    # @overload set_pen(pen)
+    #   Sets the pen used for stroking.
+    #   @param pen [Wx::Pen] 
+    #   @return [void]
+    # @overload set_pen(pen)
+    #   Sets the pen used for stroking.
+    #   @param pen [Wx::GraphicsPen] 
+    #   @return [void]
+    def set_pen(*args) end
+    alias_method :pen=, :set_pen
+    
+    # @overload draw_bitmap(bmp, x, y, w, h)
+    #   Draws the bitmap.
+    #   
+    #   In case of a mono bitmap, this is treated as a mask and the current brushed is used for filling.
+    #   @param bmp [Wx::GraphicsBitmap] 
+    #   @param x [Float] 
+    #   @param y [Float] 
+    #   @param w [Float] 
+    #   @param h [Float] 
+    #   @return [void]
+    # @overload draw_bitmap(bmp, x, y, w, h)
+    #   This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
+    #   @param bmp [Wx::Bitmap] 
+    #   @param x [Float] 
+    #   @param y [Float] 
+    #   @param w [Float] 
+    #   @param h [Float] 
+    #   @return [void]
+    # @overload draw_bitmap(bmp, rect)
+    #   This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
+    #   @param bmp [Wx::GraphicsBitmap] 
+    #   @param rect [Wx::Rect2DDouble] 
+    #   @return [void]
+    def draw_bitmap(*args) end
+    
+    # @overload draw_ellipse(x, y, w, h)
+    #   Draws an ellipse.
+    #   @param x [Float] 
+    #   @param y [Float] 
+    #   @param w [Float] 
+    #   @param h [Float] 
+    #   @return [void]
+    # @overload draw_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 draw_ellipse(*args) end
+    
+    # @overload draw_icon(icon, x, y, w, h)
+    #   Draws the icon.
+    #   @param icon [Wx::Icon] 
+    #   @param x [Float] 
+    #   @param y [Float] 
+    #   @param w [Float] 
+    #   @param h [Float] 
+    #   @return [void]
+    # @overload draw_icon(icon, rect)
+    #   This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
+    #   @param icon [Wx::Icon] 
+    #   @param rect [Wx::Rect2DDouble] 
+    #   @return [void]
+    def draw_icon(*args) end
+    
+    # Draws the path by first filling and then stroking.
+    # @param path [Wx::GraphicsPath] 
+    # @param fillStyle [Wx::PolygonFillMode] 
+    # @return [void]
+    def draw_path(path, fillStyle=Wx::PolygonFillMode::ODDEVEN_RULE) end
+    
+    # @overload draw_rectangle(x, y, w, h)
+    #   Draws a rectangle.
+    #   @param x [Float] 
+    #   @param y [Float] 
+    #   @param w [Float] 
+    #   @param h [Float] 
+    #   @return [void]
+    # @overload draw_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 draw_rectangle(*args) end
+    
+    # @overload draw_rounded_rectangle(x, y, w, h, radius)
+    #   Draws a rounded rectangle.
+    #   @param x [Float] 
+    #   @param y [Float] 
+    #   @param w [Float] 
+    #   @param h [Float] 
+    #   @param radius [Float] 
+    #   @return [void]
+    # @overload draw_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 draw_rounded_rectangle(*args) end
+    
+    # @overload draw_text(str, x, y)
+    #   Draws text at the defined position.
+    #   @param str [String] 
+    #   @param x [Float] 
+    #   @param y [Float] 
+    #   @return [void]
+    # @overload draw_text(str, pt)
+    #   This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
+    #   @param str [String] 
+    #   @param pt [Wx::Point2DDouble] 
+    #   @return [void]
+    # @overload draw_text(str, x, y, angle)
+    #   Draws text at the defined position.
+    #   @param str [String]  The text to draw.
+    #   @param x [Float]  The x coordinate position to draw the text at.
+    #   @param y [Float]  The y coordinate position to draw the text at.
+    #   @param angle [Float]  The angle, in radians, relative to the (default) horizontal direction to draw the string.
+    #   @return [void]
+    # @overload draw_text(str, x, y, backgroundBrush)
+    #   Draws text at the defined position.
+    #   @param str [String]  The text to draw.
+    #   @param x [Float]  The x coordinate position to draw the text at.
+    #   @param y [Float]  The y coordinate position to draw the text at.
+    #   @param backgroundBrush [Wx::GraphicsBrush]  Brush to fill the text with.
+    #   @return [void]
+    # @overload draw_text(str, x, y, angle, backgroundBrush)
+    #   Draws text at the defined position.
+    #   @param str [String]  The text to draw.
+    #   @param x [Float]  The x coordinate position to draw the text at.
+    #   @param y [Float]  The y coordinate position to draw the text at.
+    #   @param angle [Float]  The angle, in radians, relative to the (default) horizontal direction to draw the string.
+    #   @param backgroundBrush [Wx::GraphicsBrush]  Brush to fill the text with.
+    #   @return [void]
+    def draw_text(*args) end
+    
+    # @overload clear_rectangle(x, y, w, h)
+    #   Paints a transparent rectangle (only useful for bitmaps or windows).
+    #   @param x [Float] 
+    #   @param y [Float] 
+    #   @param w [Float] 
+    #   @param h [Float] 
+    #   @return [void]
+    # @overload clear_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 clear_rectangle(*args) end
+    
+    # Creates a native graphics path which is initially empty.
+    # @return [Wx::GraphicsPath]
+    def create_path; end
+    
+    # Fills the path with the current brush.
+    # @param path [Wx::GraphicsPath] 
+    # @param fillStyle [Wx::PolygonFillMode] 
+    # @return [void]
+    def fill_path(path, fillStyle=Wx::PolygonFillMode::ODDEVEN_RULE) end
+    
+    # @overload stroke_line(x1, y1, x2, y2)
+    #   Strokes a single line.
+    #   @param x1 [Float] 
+    #   @param y1 [Float] 
+    #   @param x2 [Float] 
+    #   @param y2 [Float] 
+    #   @return [void]
+    # @overload stroke_line(pt1, pt2)
+    #   This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
+    #   @param pt1 [Wx::Point2DDouble] 
+    #   @param pt2 [Wx::Point2DDouble] 
+    #   @return [void]
+    def stroke_line(*args) end
+    
+    # Strokes along a path with the current pen.
+    # @param path [Wx::GraphicsPath] 
+    # @return [void]
+    def stroke_path(path) end
+    
+    # @overload create_font(font, col=Wx::BLACK)
+    #   Creates a native graphics font from a {Wx::Font} and a text colour.
+    #   
+    #   <div class="wxrb-remark">
+    #   <b>Remark:</b>
+    #   <p>For Direct2D graphics, fonts can be created from TrueType fonts only. 
+    #   </p>
+    #   </div>
+    #   @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 font object with the specified attributes.
+    #   
+    #   The use of overload taking {Wx::Font} is preferred, see {Wx::GraphicsRenderer#create_font} for more details.
+    #   
+    #   <div class="wxrb-remark">
+    #   <b>Remark:</b>
+    #   <p>For Direct2D, graphics fonts can be created from TrueType fonts only.
+    #   </p>
+    #   </div>
+    #   @param sizeInPixels [Float] 
+    #   @param facename [String] 
+    #   @param flags [Integer] 
+    #   @param col [Wx::Colour,String,Symbol] 
+    #   @return [Wx::GraphicsFont]
+    def create_font(*args) end
+    
+    # @overload set_font(font, colour)
+    #   Sets the font for drawing text.
+    #   
+    #   <div class="wxrb-remark">
+    #   <b>Remark:</b>
+    #   <p>For Direct2D, only TrueType fonts can be used. 
+    #   </p>
+    #   </div>
+    #   @param font [Wx::Font,Wx::FontInfo] 
+    #   @param colour [Wx::Colour,String,Symbol] 
+    #   @return [void]
+    # @overload set_font(font)
+    #   Sets the font for drawing text.
+    #   @param font [Wx::GraphicsFont] 
+    #   @return [void]
+    def set_font(*args) end
+    alias_method :font=, :set_font
+    
+    # Fills the widths array with the widths from the beginning of text to the corresponding character of text.
+    # @param text [String] 
+    # @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.
+    # @param text [String]  The text string to measure.
+    # @return [Array(Float,Float,Float,Float)]
+    def get_text_extent(text) end
+    alias_method :text_extent, :get_text_extent
+    
+    # Begin a new document (relevant only for printing / pdf / etc.) If there is a progress dialog, message will be shown.
+    # @param message [String] 
+    # @return [Boolean]
+    def start_doc(message) end
+    
+    # Done with that document (relevant only for printing / pdf / etc.).
+    # @return [void]
+    def end_doc; end
+    
+    # Opens a new page (relevant only for printing / pdf etc.) with the given size in points.
+    # 
+    # (If both are nil, then the default page size will be used.)
+    # @param width [Float] 
+    # @param height [Float] 
+    # @return [void]
+    def start_page(width=0, height=0) end
+    
+    # Ends the current page (relevant only for printing / pdf / etc.).
+    # @return [void]
+    def end_page; end
+    
+    # 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 {Wx::Image} to {Wx::Bitmap} first and then calling {Wx::GraphicsContext#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
+    
+    # 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
+    
+    # All rendering will be done into a fully transparent, temporary context.
+    # 
+    # Layers can be nested by making balanced calls to {Wx::GraphicsContext#begin_layer}/EndLayer().
+    # @param opacity [Float] 
+    # @return [void]
+    def begin_layer(opacity) end
+    
+    # Composites back the drawings into the context with the opacity given at the {Wx::GraphicsContext#begin_layer} call.
+    # @return [void]
+    def end_layer; end
+    
+    # Push the current state (like transformations, clipping region and quality settings) of the context on a stack.
+    # 
+    # Multiple balanced calls to {Wx::GraphicsContext#push_state} and {Wx::GraphicsContext#pop_state} can be nested.
+    # @see Wx::GraphicsContext#pop_state 
+    # @return [void]
+    def push_state; end
+    
+    # Sets current state of the context to the state saved by a preceding call to {Wx::GraphicsContext#push_state} and removes that state from the stack of saved states.
+    # 
+    # 
+    # @see Wx::GraphicsContext#push_state 
+    # @return [void]
+    def pop_state; end
+    
+    # Make sure that the current content of this context is immediately visible.
+    # @return [void]
+    def flush; end
+    
+    # Sets the antialiasing mode; returns true if it supported.
+    # @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 [Wx::AntialiasMode]
+    def get_antialias_mode; end
+    alias_method :antialias_mode, :get_antialias_mode
+    
+    # Sets the interpolation quality; returns true if it is supported.
+    # 
+    # <div class="wxrb-remark">
+    # <b>Remark:</b>
+    # <p>Not implemented in the Cairo backend currently. 
+    # </p>
+    # </div>
+    # @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 [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 [Wx::CompositionMode] 
+    # @return [Boolean]
+    def set_composition_mode(op) end
+    alias_method :composition_mode=, :set_composition_mode
+    
+    # Returns the current compositing operator.
+    # @return [Wx::CompositionMode]
+    def get_composition_mode; end
+    alias_method :composition_mode, :get_composition_mode
+    
+    # Returns the size of the graphics context in device coordinates.
+    # @return [Array(Float,Float)]
+    def get_size; end
+    alias_method :size, :get_size
+    
+    # Returns the resolution of the graphics context in device points per inch.
+    # @return [Array(Float,Float)]
+    def get_dpi; end
+    alias_method :dpi, :get_dpi
+    
+    # Returns the associated window, if any.
+    # 
+    # If this context was created using {Wx::GraphicsContext.create} overload taking {Wx::Window} or {Wx::WindowDC}, this method returns the corresponding window. Otherwise, returns nil.
+    # A possibly nil window pointer.
+    # @return [Wx::Window]
+    def get_window; end
+    alias_method :window, :get_window
+    
+    # Helper to determine if a 0.5 offset should be applied for the drawing operation.
+    # @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 [Boolean] 
+    # @return [void]
+    def enable_offset(enable=true) end
+    
+    # Helper to determine if a 0.5 offset should be applied for the drawing operation.
+    # @return [void]
+    def disable_offset; end
+    
+    # Helper to determine if a 0.5 offset should be applied for the drawing operation.
+    # @return [Boolean]
+    def offset_enabled; end
+    
+    # @overload from_dip(sz)
+    #   Convert DPI-independent pixel values to the value in pixels appropriate for the graphics context.
+    #   
+    #   See {Wx::Window#from_dip} and {Wx::DC#from_dip} for more info about converting device independent pixel values.
+    #   @param sz [Array(Integer, Integer), Wx::Size] 
+    #   @return [Wx::Size]
+    # @overload from_dip(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 [Array(Integer, Integer), Wx::Point] 
+    #   @return [Wx::Point]
+    # @overload from_dip(d)
+    #   Convert DPI-independent value in pixels to the value in pixels appropriate for the graphics context.
+    #   
+    #   This is the same as the <code>Wx::GraphicsContext#from_dip(const Wx::Size&)</code> overload, but assumes that the resolution is the same in horizontal and vertical directions.
+    #   @param d [Integer] 
+    #   @return [Integer]
+    def from_dip(*args) end
+    
+    # @overload to_dip(sz)
+    #   Convert pixel values of the current graphics context to DPI-independent pixel values.
+    #   
+    #   See {Wx::Window#to_dip} and {Wx::DC#to_dip} for more info about converting device independent pixel values.
+    #   @param sz [Array(Integer, Integer), Wx::Size] 
+    #   @return [Wx::Size]
+    # @overload to_dip(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 [Array(Integer, Integer), Wx::Point] 
+    #   @return [Wx::Point]
+    # @overload to_dip(d)
+    #   Convert pixel values of the current graphics context to DPI-independent pixel values.
+    #   
+    #   This is the same as ToDIP(const {Wx::Size}&) overload, but assumes that the resolution is the same in horizontal and vertical directions.
+    #   @param d [Integer] 
+    #   @return [Integer]
+    def to_dip(*args) end
+    
+  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!
+  # @wxrb_require USE_GRAPHICS_CONTEXT
+  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!
+  # @wxrb_require USE_GRAPHICS_CONTEXT
+  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::TRANSPARENT_COLOUR, endCol=Wx::TRANSPARENT_COLOUR) end
+    
+    # 
+    # 
+    # 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
+    
+    # 
+    # 
+    # 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
+    
+    # 
+    # 
+    # 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
+    
+    # 
+    # 
+    # 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 the 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}. For example, to start drawing with a dotted blue pen slightly wider than normal you could, write the following: 
+  # ```ruby
+  #   ctx = Wx::GraphicsContext.create(dc)
+  # 
+  #   ctx.set_pen(Wx::GraphicsPenInfo.new(Wx::BLUE).width(1.25).style(Wx::PENSTYLE_DOT))
+  # ```
+  # 
+  # 
+  # @note This class is <b>untracked</b> and should not be derived from nor instances extended!
+  # @wxrb_require USE_GRAPHICS_CONTEXT
+  class GraphicsPenInfo < ::Object
+  
+    # Constructor, which can set the colour, width and style for the pen.
+    # @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
+    
+    # Sets the colour for the pen.
+    # @param col [Wx::Colour,String,Symbol] 
+    # @return [Wx::GraphicsPenInfo]
+    def colour(col) end
+    
+    # Sets the line width for the pen.
+    # @param width [Float] 
+    # @return [Wx::GraphicsPenInfo]
+    def width(width) end
+    
+    # Sets the style for the pen.
+    # @param style [Wx::PenStyle] 
+    # @return [Wx::GraphicsPenInfo]
+    def style(style) end
+    
+    # Sets the bitmap used for stippling.
+    # 
+    # When the pen is used, a repeating pattern of this bitmap will be drawn.
+    # @param stipple [Wx::Bitmap] 
+    # @return [Wx::GraphicsPenInfo]
+    def stipple(stipple) end
+    
+    # Sets the join for the pen, which is the appearance of where two lines meet or overlap.
+    # @param join [Wx::PenJoin] 
+    # @return [Wx::GraphicsPenInfo]
+    def join(join) end
+    
+    # Sets the cap (i.e., the end point) for the pen.
+    # @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)
+    #   Applies a linear gradient to the pen.
+    #   
+    #   <div class="wxrb-remark">
+    #   <b>Remark:</b>
+    #   <p>The starting and ending coordinates define the direction of the gradient. Along with north, south, east and west, diagonal directions can also be used. 
+    #   </p>
+    #   </div>
+    #   @param x1 [Float]  The x coordinate of the starting point of the gradient.
+    #   @param y1 [Float]  The y coordinate of the starting point of the gradient.
+    #   @param x2 [Float]  The x coordinate of the ending point of the gradient.
+    #   @param y2 [Float]  The y coordinate of the ending point of the gradient.
+    #   @param c1 [Wx::Colour,String,Symbol]  The starting colour.
+    #   @param c2 [Wx::Colour,String,Symbol]  The ending colour.
+    #   @param matrix [Wx::GraphicsMatrix]  An optional transformation to apply to the gradient.
+    #   @return [Wx::GraphicsPenInfo]
+    # @overload linear_gradient(x1, y1, x2, y2, stops, matrix=Wx::NULL_GRAPHICS_MATRIX)
+    #   Applies a linear gradient to the pen, including discontinuous stops in the pattern.
+    #   
+    #   <div class="wxrb-remark">
+    #   <b>Remark:</b>
+    #   <p>The starting and ending coordinates define the direction of the gradient. Along with north, south, east and west, diagonal directions can also be used. 
+    #   </p>
+    #   </div>
+    #   @param x1 [Float]  The x coordinate of the starting point of the gradient.
+    #   @param y1 [Float]  The y coordinate of the starting point of the gradient.
+    #   @param x2 [Float]  The x coordinate of the ending point of the gradient.
+    #   @param y2 [Float]  The y coordinate of the ending point of the gradient.
+    #   @param stops [Wx::GraphicsGradientStops]  A series of stops to include in the pattern.
+    #   @param matrix [Wx::GraphicsMatrix]  An optional transformation to apply to the gradient.
+    #   @return [Wx::GraphicsPenInfo]
+    def linear_gradient(*args) end
+    
+    # @overload radial_gradient(startX, startY, endX, endY, radius, oColor, cColor, matrix=Wx::NULL_GRAPHICS_MATRIX)
+    #   Applies a radial (i.e., circular) gradient to the pen.
+    #   
+    #   <div class="wxrb-remark">
+    #   <b>Remark:</b>
+    #   <p>The starting and ending coordinates define the direction of the gradient. Along with north, south, east and west, diagonal directions can also be used. 
+    #   </p>
+    #   </div>
+    #   @param startX [Float]  The x coordinate of the starting point of the gradient.
+    #   @param startY [Float]  The startY coordinate of the starting point of the gradient.
+    #   @param endX [Float]  The endX coordinate of the end of the circle.
+    #   @param endY [Float]  The endY coordinate of the end of the circle.
+    #   @param radius [Float]  The radius of the circle of the gradient (around endX and endY).
+    #   @param oColor [Wx::Colour,String,Symbol]  The outer colour.
+    #   @param cColor [Wx::Colour,String,Symbol]  The center colour.
+    #   @param matrix [Wx::GraphicsMatrix]  An optional transformation to apply to the gradient.
+    #   @return [Wx::GraphicsPenInfo]
+    # @overload radial_gradient(startX, startY, endX, endY, radius, stops, matrix=Wx::NULL_GRAPHICS_MATRIX)
+    #   Applies a radial (i.e., circular) gradient to the pen, including discontinuous stops in the pattern.
+    #   
+    #   <div class="wxrb-remark">
+    #   <b>Remark:</b>
+    #   <p>The starting and ending coordinates define the direction of the gradient. Along with north, south, east and west, diagonal directions can also be used. 
+    #   </p>
+    #   </div>
+    #   @param startX [Float]  The x coordinate of the starting point of the gradient.
+    #   @param startY [Float]  The startY coordinate of the starting point of the gradient.
+    #   @param endX [Float]  The endX coordinate of the end of the circle.
+    #   @param endY [Float]  The endY coordinate of the end of the circle.
+    #   @param radius [Float]  The radius of the circle of the gradient (around endX and endY).
+    #   @param stops [Wx::GraphicsGradientStops]  A series of stops to include in the pattern.
+    #   @param matrix [Wx::GraphicsMatrix]  An optional transformation to apply to the gradient.
+    #   @return [Wx::GraphicsPenInfo]
+    def radial_gradient(*args) end
+    
+    # Returns the pen's colour.
+    # @return [Wx::Colour]
+    def get_colour; end
+    
+    # Returns the pen's stipple bitmap.
+    # @return [Wx::Bitmap]
+    def get_stipple; end
+    
+    # Returns the pen's style.
+    # @return [Wx::PenStyle]
+    def get_style; end
+    
+    # Returns the pen's joining method.
+    # @return [Wx::PenJoin]
+    def get_join; end
+    
+    # Returns the pen's cap (i.e., end-point style).
+    # @return [Wx::PenCap]
+    def get_cap; end
+    
+    # Returns the number of dashes in the pen's dash pattern.
+    # @return [Integer]
+    def get_dash_count; end
+    alias_method :dash_count, :get_dash_count
+    
+    # Returns whether the pen is transparent.
+    # @return [Boolean]
+    def is_transparent; end
+    alias_method :transparent?, :is_transparent
+    
+    # Returns the pen's line width.
+    # @return [Float]
+    def get_width; end
+    
+    # Returns the pen's gradient type.
+    # @return [Wx::GradientType]
+    def get_gradient_type; end
+    alias_method :gradient_type, :get_gradient_type
+    
+    # Returns the x coordinate of the starting point (if using a gradient).
+    # @return [Float]
+    def get_x1; end
+    alias_method :x1, :get_x1
+    
+    # Returns the y coordinate of the starting point (if using a gradient).
+    # @return [Float]
+    def get_y1; end
+    alias_method :y1, :get_y1
+    
+    # Returns the x coordinate of the ending point (if using a gradient).
+    # @return [Float]
+    def get_x2; end
+    alias_method :x2, :get_x2
+    
+    # Returns the y coordinate of the ending point (if using a gradient).
+    # @return [Float]
+    def get_y2; end
+    alias_method :y2, :get_y2
+    
+    # Returns the x coordinate of the starting point (if using a gradient).
+    # @return [Float]
+    def get_start_x; end
+    alias_method :start_x, :get_start_x
+    
+    # Returns the y coordinate of the starting point (if using a gradient).
+    # @return [Float]
+    def get_start_y; end
+    alias_method :start_y, :get_start_y
+    
+    # Returns the x coordinate of the ending point (if using a gradient).
+    # @return [Float]
+    def get_end_x; end
+    alias_method :end_x, :get_end_x
+    
+    # Returns the y coordinate of the ending point (if using a gradient).
+    # @return [Float]
+    def get_end_y; end
+    alias_method :end_y, :get_end_y
+    
+    # Returns the radius of the radial gradient.
+    # @return [Float]
+    def get_radius; end
+    alias_method :radius, :get_radius
+    
+    # Returns the stops of the gradient.
+    # @return [Wx::GraphicsGradientStops]
+    def get_stops; end
+    alias_method :stops, :get_stops
+    
+  end # GraphicsPenInfo
+  
+
+end