rmagick 5.4.4 → 5.5.0

data/sig/rvg/pathdata.rbs

@@ -0,0 +1,77 @@
+module Magick
+  class RVG
+    # The PathData class provides an object-oriented way to produce an SVG
+    # path. Each of the methods corresponds to a path command. Construct a
+    # path by calling one or more methods. The path object can be passed
+    # as an argument to the RVG::ShapeConstructors#path method.
+    class PathData
+      @path: String
+
+      private
+
+      def add_points: (Integer req, *magick_real coords) -> void
+
+      public
+
+      # Construct an empty path
+      def initialize: () -> void
+
+      # Convert the path to its string equivalent.
+      def to_s: () -> String
+
+      # @private
+      def deep_copy: (?untyped? _h) -> String
+
+      # Add a <tt>moveto</tt> command. If <tt>abs</tt> is
+      # <tt>true</tt> the coordinates are absolute, otherwise
+      # the coordinates are relative.
+      def moveto: (bool abs, magick_real x, magick_real y, *magick_real coords) -> void
+
+      # Add a <tt>closepath</tt> command. The <tt>abs</tt> argument
+      # is ignored.
+      def closepath: (?bool _abs) -> void
+
+      # Add a <tt>lineto</tt> command. Any number of x,y coordinate
+      # pairs may be specified. If <tt>abs</tt> is
+      # <tt>true</tt> the coordinates are absolute, otherwise
+      # the coordinates are relative.
+      def lineto: (bool abs, magick_real x, magick_real y, *magick_real coords) -> void
+
+      # Add a <tt>horizontal lineto</tt> command. If <tt>abs</tt> is
+      # <tt>true</tt> the coordinates are absolute, otherwise
+      # the coordinates are relative.
+      def hlineto: (bool abs, magick_real x) -> void
+
+      # Add a <tt>vertical lineto</tt> command. If <tt>abs</tt> is
+      # <tt>true</tt> the coordinates are absolute, otherwise
+      # the coordinates are relative.
+      def vlineto: (bool abs, magick_real y) -> void
+
+      # Add a <tt>curveto</tt> (<em>cubic Bezier</em>) command.
+      # If <tt>abs</tt> is
+      # <tt>true</tt> the coordinates are absolute, otherwise
+      # the coordinates are relative.
+      def curveto: (bool abs, magick_real x1, magick_real y1, magick_real x2, magick_real y2, magick_real x, magick_real y, *magick_real coords) -> void
+
+      # Add a <tt>smooth curveto</tt> (<em>cubic Bezier</em>) command.
+      # If <tt>abs</tt> is
+      # <tt>true</tt> the coordinates are absolute, otherwise
+      # the coordinates are relative.
+      def smooth_curveto: (bool abs, magick_real x2, magick_real y2, magick_real x, magick_real y, *magick_real coords) -> void
+
+      # Add a <tt>quadratic Bezier curveto</tt> command.
+      # If <tt>abs</tt> is
+      # <tt>true</tt> the coordinates are absolute, otherwise
+      # the coordinates are relative.
+      def quadratic_curveto: (bool abs, magick_real x1, magick_real y1, magick_real x, magick_real y, *magick_real coords) -> void
+
+      # Add a <tt>smooth quadratic Bezier curveto</tt> command.
+      # If <tt>abs</tt> is
+      # <tt>true</tt> the coordinates are absolute, otherwise
+      # the coordinates are relative.
+      def smooth_quadratic_curveto: (bool abs, magick_real x, magick_real y, *magick_real coords) -> void
+
+      def arc: (bool abs, magick_real rx, magick_real ry, magick_real x_axis_rotation, magick_real large_arc_flag, magick_real sweep_flag, magick_real x, magick_real y) -> void
+    end
+  end
+end

data/sig/rvg/rvg.rbs

@@ -0,0 +1,125 @@
+module Magick
+  class RVG
+    @background_image: untyped
+    @background_pattern: untyped
+    @background_position: untyped
+    @background_fill: untyped
+    @background_fill_opacity: untyped
+    @width: untyped
+    @height: untyped
+    @content: Content
+    @canvas: Magick::Image
+    @desc: untyped
+    @title: untyped
+    @metadata: untyped
+    @x: untyped
+    @y: untyped
+    @nested: untyped
+
+    include Stylable
+    include Transformable
+    include Stretchable
+    include Embellishable
+    include Describable
+    include Duplicatable
+
+    interface _Duplicatable
+      def deep_copy: (?Hash[untyped, untyped] h) -> self
+    end
+
+    # The background image specified by background_image=
+    attr_reader background_image: Magick::Image
+
+    # The background image layout specified by background_position=
+    attr_reader background_position: Symbol
+
+    # The background fill color specified by background_fill=
+    attr_reader background_fill: Magick::Pixel
+
+    # The background fill color opacity specified by background_fill_opacity=
+    attr_reader background_fill_opacity: Float
+
+    # The image after drawing has completed
+    attr_reader canvas: Magick::Image
+
+    # For embedded RVG objects, the x-axis coordinate of the upper-left corner
+    attr_reader x: Float
+
+    # For embedded RVG objects, the x-axis coordinate of the upper-left corner
+    attr_reader y: Float
+
+    attr_reader width: Float
+
+    attr_reader height: Float
+
+    private
+
+    def bgfill: () -> Magick::Pixel
+    def new_canvas: () ->  Magick::Image
+
+    public
+
+
+    # Sets an image to use as the canvas background. See background_position= for layout options.
+    def background_image=: (Magick::Image? bg_image) -> Magick::Image?
+
+    # Sets an object to use to fill the canvas background.
+    # The object must have a <tt>fill</tt> method. See the <b>Fill Classes</b>
+    # section in the RMagick doc for more information.
+    def background_pattern=: (magick_fill filler) -> magick_fill
+
+    # How to position the background image on the canvas. One of the following symbols:
+    # [:scaled] Scale the image to the canvas width and height.
+    # [:tiled]  Tile the image across the canvas.
+    # [:fit] Scale the image to fit within the canvas while retaining the
+    #        image proportions. Center the image on the canvas. Color any part of
+    #        the canvas not covered by the image with the background color.
+    def background_position=: (interned pos) -> Symbol
+
+    # Sets the canvas background color. Either a Magick::Pixel or a color name.
+    # The default fill is "none", that is, transparent black.
+    def background_fill=: (magick_color color) -> Magick::Pixel
+
+    # Opacity of the background fill color, a number between 0.0 (transparent) and
+    # 1.0 (opaque). The default is 1.0 when the background_fill= attribute has been set.
+    def background_fill_opacity=: (magick_real opacity) -> magick_real
+
+    # Draw a +width+ x +height+ image. The image is specified by calling
+    # one or more drawing methods on the RVG object.
+    # You can group the drawing method calls in the optional associated block.
+    # The +x+ and +y+ arguments have no meaning for the outermost RVG object.
+    # On nested RVG objects [+x+, +y+] is the coordinate of the upper-left
+    # corner in the containing canvas on which the nested RVG object is placed.
+    #
+    # Drawing occurs on a +canvas+ created by the #draw method. By default the
+    # canvas is transparent. You can specify a different canvas with the
+    # #background_fill= or #background_image= methods.
+    #
+    # RVG objects are _containers_. That is, styles and transforms defined
+    # on the object are used by contained objects such as shapes, text, and
+    # groups unless overridden by an inner container or the object itself.
+    def initialize: (?magick_real? width, ?magick_real? height) -> void
+                  | (?magick_real? width, ?magick_real? height) { (RVG) -> void } -> void
+
+    # Construct a canvas or reuse an existing canvas.
+    # Execute drawing commands. Return the canvas.
+    def draw: () -> Magick::Image
+
+    # Accept #use arguments. Use (x,y) to generate an additional translate.
+    # Override @width and @height if new values are supplied.
+    # @private
+    def ref: (Integer | Float x, Integer | Float y, Integer | Float rw, Integer | Float rh) -> void
+
+    # Used by Magick::Embellishable.rvg to set non-0 x- and y-coordinates
+    # @private
+    def corner: (magick_real x, magick_real y) -> void
+
+    # Primitives for the outermost RVG object
+    # @private
+    def add_outermost_primitives: (Utility::GraphicContext gc) -> self
+
+    # Primitives for nested RVG objects
+    # @private
+    def add_primitives: (Utility::GraphicContext gc) -> void
+  end
+end

data/sig/rvg/stretchable.rbs

@@ -0,0 +1,56 @@
+module Magick
+  class RVG
+    module PreserveAspectRatio
+      @align: String
+      @meet_or_slice: String
+
+      # -
+      #   Included in Stretchable module and Image class
+      # +
+      # Specifies how the image within a viewport should be scaled.
+      # [+align+] a combination of 'xMin', 'xMid', or 'xMax', followed by
+      #           'YMin', 'YMid', or 'YMax'
+      # [+meet_or_slice+] one of 'meet' or 'slice'
+      def preserve_aspect_ratio: (interned align, ?interned meet_or_slice) -> self
+                               | (interned align, ?interned meet_or_slice) { (self) -> void } -> self
+    end
+
+    # The methods in this module describe the user-coordinate space.
+    # RVG and Pattern objects are stretchable.
+    module Stretchable
+      @vbx_width: Float
+      @vbx_height: Float
+      @vbx_x: Float
+      @vbx_y: Float
+      @meet_or_slice: String
+      @align: String
+
+      include PreserveAspectRatio
+
+      private
+
+      # Scale to fit
+      def set_viewbox_none: (Integer | Float width, Integer | Float height) -> [Integer | Float, Integer | Float]
+
+      # Use align attribute to compute x- and y-offset from viewport's upper-left corner.
+      def align_to_viewport: (Integer | Float width, Integer | Float height, Integer | Float sx, Integer | Float sy) -> [(Integer | Float)?, (Integer | Float)?]
+
+      # Scale to smaller viewbox dimension
+      def set_viewbox_meet: (Integer | Float width, Integer | Float height) -> [(Integer | Float)?, (Integer | Float)?]
+
+      # Scale to larger viewbox dimension
+      def set_viewbox_slice: (Integer | Float width, Integer | Float height) -> [(Integer | Float)?, (Integer | Float)?]
+
+      # Establish the viewbox as necessary
+      def add_viewbox_primitives: (Integer | Float width, Integer | Float height, Utility::GraphicContext gc) -> void
+
+      public
+
+      # Describe a user coordinate system to be imposed on the viewbox.
+      # The arguments must be numbers and the +width+ and +height+
+      # arguments must be positive.
+      def viewbox: (magick_real x, magick_real y, magick_real width, magick_real height) -> self
+                 | (magick_real x, magick_real y, magick_real width, magick_real height) { (self) -> void } -> self
+    end
+  end
+end

data/sig/rvg/stylable.rbs

@@ -0,0 +1,66 @@
+module Magick
+  class RVG
+    # Styles is a Struct class with a couple of extra methods
+    class Styles < Struct[untyped]
+      def set: (Hash[Symbol, untyped] styles) -> self
+
+      # Iterate over the style names. Yield for each style that has a value.
+      def each_value: () { (Symbol, untyped) -> void } -> void
+
+      # The "usual" deep_copy method doesn't copy a Struct correctly.
+      def deep_copy: (?untyped? _h) -> Styles
+
+      def self.new: (*untyped obj) -> Styles
+    end
+
+    # This module is mixed into classes that can have styles.
+    module Stylable
+      @styles: Styles
+
+      private
+
+      # For each style that has a value, add a style primitive to the gc.
+      # Use splat to splat out Array arguments such as stroke_dasharray.
+      def add_style_primitives: (Utility::GraphicContext gc) -> void
+
+      public
+
+      # This method can be used with any RVG, Group, Use, Text, or
+      # shape object. The argument is a hash. The style names are
+      # the hash keys. The style names and values are:
+      # [:baseline_shift] modify the text baseline
+      # [:clip_path] clipping path defined by clip_path
+      # [:clip_rule] 'evenodd' or 'nozero'
+      # [:fill] color name
+      # [:fill_opacity] the fill opacity, 0.0<=N<=1.0
+      # [:fill_rule] 'evenodd' or 'nozero'
+      # [:font] font name or font file name
+      # [:font_family] font family name, ex. 'serif'
+      # [:font_size] font size in points
+      # [:font_stretch] 'normal','ultra_condensed','extra_condensed',
+      #                 'condensed','semi_condensed','semi_expanded',
+      #                 'expanded','extra_expanded','ultra_expanded'
+      # [:font_style] 'normal','italic','oblique'
+      # [:font_weight] 'normal','bold','bolder','lighter', or
+      #                a multiple of 100 between 100 and 900.
+      # [:glyph_orientation_horizontal] 0, 90, 180, 270
+      # [:glyph_orientation_vertical] 0, 90, 180, 270
+      # [:letter_spacing] modify the spacing between letters
+      # [:opacity] both fill and stroke opacity, 0.0<=N<=1.0
+      # [:stroke] color name
+      # [:stroke_dasharray] dash pattern (Array)
+      # [:stroke_dashoffset] initial distance into dash pattern
+      # [:stroke_linecap] 'butt', 'round', 'square'
+      # [:stroke_linejoin] 'miter', 'round', 'bevel'
+      # [:stroke_miterlimit] miter length constraint
+      # [:stroke_opacity] the stroke opacity, 0.0<=N<=1.0
+      # [:stroke_width] stroke width
+      # [:text_anchor] 'start','middle','end'
+      # [:text_decoration] 'none','underline','overline','line_through'
+      # [:word_spacing] modify the spacing between words
+      # [:writing_mode] 'lr-tb', 'lr', 'rt-tb', 'rl', 'tb-rl', 'tb'
+      def styles: (Hash[Symbol, untyped] styles) -> self
+                | (Hash[Symbol, untyped] styles) { (self) -> void } -> self
+    end
+  end
+end

data/sig/rvg/text.rbs

@@ -0,0 +1,118 @@
+# -
+# $Id: text.rb,v 1.7 2009/02/28 23:52:28 rmagick Exp $
+# Copyright (C) 2009 Timothy P. Hunter
+# +
+# Text-related classes
+module Magick
+  class RVG
+    # Base class for Tspan, Tref and Text.
+    class TextBase
+      @text: String?
+      @dx: Integer | Float
+      @rotation: Integer | Float
+      @tspans: Content
+      @dy: Integer | Float
+
+      include Stylable
+      include Duplicatable
+
+      def initialize: (interned? text) -> void
+                    |  (interned? text) { (self) -> void } -> void
+
+      # Create a new text chunk. Each chunk can have its own initial position and styles.
+      # If <tt>x</tt> and <tt>y</tt> are omitted the text starts at the current text
+      # position.
+      def tspan: (interned text, ?magick_real? x, ?magick_real? y) -> Tspan
+               | (interned text, ?magick_real? x, ?magick_real? y) { (self) -> void } -> Tspan
+
+      # Add <tt>x</tt> and <tt>y</tt> to the current text position.
+      def d: (magick_real x, ?magick_real y) -> self
+           | (magick_real x, ?magick_real y) { (self) -> void } -> self
+
+      # Rotate the text about the current text position.
+      def rotate: (magick_real degrees) -> self
+                | (magick_real degrees) { (self) -> void } -> self
+
+      # We do our own transformations.
+      # @private
+      def add_primitives: (Utility::GraphicContext gc) -> void
+    end
+
+    # Tspan and Tref shared methods - read/update @cx, @cy in parent Text object.
+    # @private
+    module TextLink
+      def add_primitives: (Utility::GraphicContext gc) -> void
+      def cx: () -> Float
+      def cy: () -> Float
+      def cx=: (magick_real x) -> magick_real
+      def cy=: (magick_real y) -> magick_real
+    end
+
+    # @private
+    class Tref < TextBase
+      @x: Float
+      @y: Float
+      @parent: TextBase
+
+      include TextLink
+
+      def initialize: (TextBase obj, magick_real x, magick_real y, TextBase parent) -> void
+    end
+
+    # @private
+    class Tspan < TextBase
+      @x: Float
+      @y: Float
+
+      include TextLink
+
+      attr_accessor parent: TextBase
+
+      # Define a text segment starting at (<tt>x</tt>, <tt>y</tt>).
+      # If <tt>x</tt> and <tt>y</tt> are omitted the segment starts
+      # at the current text position.
+      #
+      # Tspan objects can contain Tspan objects.
+      def initialize: (?interned? text, ?magick_real? x, ?magick_real? y) -> void
+                    | (?interned? text, ?magick_real? x, ?magick_real? y) { (Tspan) -> void } -> void
+    end
+
+    class Text < TextBase
+      @cx: Float
+      @cy: Float
+
+      # @private
+      attr_accessor cx: Float
+
+      # @private
+      attr_accessor cy: Float
+
+      # Define a text string starting at [<tt>x</tt>, <tt>y</tt>].
+      # Use the RVG::TextConstructors#text method to create Text objects in a container.
+      #
+      #  container.text(100, 100, "Simple text").styles(:font=>'Arial')
+      #
+      # Text objects can contain Tspan objects.
+      #
+      #  container.text(100, 100).styles(:font=>'Arial') do |t|
+      #     t.tspan("Red text").styles(:fill=>'red')
+      #     t.tspan("Blue text").styles(:fill=>'blue')
+      #  end
+      def initialize: (?magick_real x, ?magick_real y, ?interned? text) -> void
+                    | (?magick_real x, ?magick_real y, ?interned? text) { (Text) -> void } -> void
+
+      # Reference a Tspan object. <tt>x</tt> and <tt>y</tt> are just
+      # like <tt>x</tt> and <tt>y</tt> in RVG::TextBase#tspan
+      def tref: (TextBase obj, ?magick_real? x, ?magick_real? y) -> Tref
+    end
+
+    # Methods that construct text objects within a container
+    module TextConstructors
+      # Draw a text string at (<tt>x</tt>,<tt>y</tt>). The string can
+      # be omitted. Optionally, define text chunks within the associated
+      # block.
+      def text: (?magick_real x, ?magick_real y, ?interned? text) -> Text
+              | (?magick_real x, ?magick_real y, ?interned? text) { (Text) -> void } -> Text
+    end
+  end
+end

data/sig/rvg/transformable.rbs

@@ -0,0 +1,59 @@
+module Magick
+  class RVG
+    # Transforms is an Array with a deep_copy method.
+    # During unit-testing it also has a deep_equal method.
+    # @private
+    class Transforms < Array[untyped]
+      def deep_copy: (?untyped? _h) -> Transforms
+    end
+
+    # Transformations are operations on the coordinate system.
+    # All the transformations defined within a container (an RVG object
+    # or a group) are applied before drawing any shapes or text.
+    # All transformations are applied in the order they were
+    # defined. <em>Note:</em> This means that
+    #   g.translate(10,20).scale(2)
+    # is not the same as
+    #   g.scale(2).translate(10,20)
+    module Transformable
+      @transforms: Transforms
+
+      private
+
+      # Apply transforms in the same order they were specified!
+      def add_transform_primitives: (Utility::GraphicContext gc) -> void
+
+      public
+
+      # Applies the transformation matrix [sx, rx, ry, sy, tx, ty]
+      def matrix: (magick_real sx, magick_real rx, magick_real ry, magick_real sy, magick_real tx, magick_real ty) -> self
+                | (magick_real sx, magick_real rx, magick_real ry, magick_real sy, magick_real tx, magick_real ty) { (self) -> void } -> self
+
+      # Add <tt>tx</tt> to all x-coordinates and <tt>ty</tt>
+      # to all y-coordinates. If <tt>ty</tt> is omitted it defaults
+      # to <tt>tx</tt>.
+      def translate: (magick_real tx, ?magick_real? ty) -> self
+                   | (magick_real tx, ?magick_real? ty) { (self) -> void } -> self
+
+      # Multiply the x-coordinates by <tt>sx</tt> and the y-coordinates
+      # by <tt>sy</tt>. If <tt>sy</tt> is omitted it defaults to <tt>sx</tt>.
+      def scale: (magick_real sx, ?magick_real? sy) -> self
+               | (magick_real sx, ?magick_real? sy) { (self) -> void } -> self
+
+      # This method can take either of two argument lists:
+      # [rotate(angle)] rotate by <tt>angle</tt> degrees
+      # [rotate(angle, cx, cy)] rotate by <tt>angle</tt> degrees about
+      #                         the point [<tt>cx</tt>, <tt>cy</tt>].
+      def rotate: (magick_real angle, *magick_real args) -> self
+                | (magick_real angle, *magick_real args) { (self) -> void } -> self
+
+      # Skew the X-axis by <tt>angle</tt> degrees.
+      def skewX: (magick_real angle) -> self
+               | (magick_real angle) { (self) -> void } -> self
+
+      # Skew the Y-axis by <tt>angle</tt> degrees.
+      def skewY: (magick_real angle) -> self
+               | (magick_real angle) { (self) -> void } -> self
+    end
+  end
+end

data/sig/rvg/units.rbs

@@ -0,0 +1,33 @@
+module Magick
+  class RVG
+    attr_reader self.dpi: Float
+
+    def self.dpi=: (magick_real n) -> Float
+  end
+end
+
+class Float
+  attr_reader px: Float
+  attr_reader in: Float
+  attr_reader mm: Float
+  attr_reader cm: Float
+  attr_reader pt: Float
+  attr_reader pc: Float
+  def pct: (Magick::magick_real of) -> Float
+  attr_reader deg: Float
+  attr_reader rad: Float
+  attr_reader grad: Float
+end
+
+class Integer
+  attr_reader px: Integer
+  attr_reader in: Float
+  attr_reader mm: Float
+  attr_reader cm: Float
+  attr_reader pt: Float
+  attr_reader pc: Float
+  def pct: (Magick::magick_real of) -> Float
+  attr_reader deg: Integer
+  attr_reader rad: Float
+  attr_reader grad: Float
+end