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

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

@@ -165,33 +165,31 @@ module Wx
   # 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.
   # 
-  # ```
-  #   void MyCanvas::OnPaint(wxPaintEvent &event)
-  #   {
-  #       // Create paint DC
-  #       wxPaintDC dc(this);
-  #   
-  #       // Create graphics context from it
-  #       wxGraphicsContext *gc = wxGraphicsContext::Create( dc );
-  #   
-  #       if (gc)
-  #       {
-  #           // make a path that contains a circle and some lines
-  #           gc->SetPen( *wxRED_PEN );
-  #           wxGraphicsPath path = gc->CreatePath();
-  #           path.AddCircle( 50.0, 50.0, 50.0 );
-  #           path.MoveToPoint(0.0, 50.0);
-  #           path.AddLineToPoint(100.0, 50.0);
-  #           path.MoveToPoint(50.0, 0.0);
-  #           path.AddLineToPoint(50.0, 100.0 );
-  #           path.CloseSubpath();
-  #           path.AddRectangle(25.0, 25.0, 50.0, 50.0);
-  #   
-  #           gc->StrokePath(path);
-  #   
-  #           delete gc;
-  #       }
-  #   }
+  # ```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
   # ```
   # 
   # For some renderers (like Direct2D or Cairo) processing of drawing operations may be deferred (Direct2D render target normally builds up a batch of rendering commands but defers processing of these commands, Cairo operates on a separate surface) so to make drawing results visible you need to update the content of the context by calling {Wx::GraphicsContext#flush} or by destroying the context.
@@ -216,7 +214,10 @@ module Wx
     #   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.
     #   
-    #   - 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).
+    #   - 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).
     #   @param region [Wx::Region] 
     #   @return [void]
     # @overload clip(x, y, w, h)
@@ -230,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] 
@@ -412,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
     
@@ -477,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
     
@@ -489,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]
@@ -537,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.
@@ -550,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.)
@@ -617,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
     
@@ -656,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.
@@ -670,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
     
@@ -684,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)
@@ -721,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