rmagick 5.4.4 → 5.5.0

data/sig/rmagick.rbs

@@ -0,0 +1,43 @@
+module Magick
+  # A real number, ie not a `Complex`.
+  type magick_real = Integer | Float | Rational | _ToF
+  # A percentage, a real number or a string in the form "NN%"
+  type magick_percentage = magick_real | String
+
+  type magick_image = Image | ImageList
+
+  type magick_color = Pixel | string
+
+  type magick_fill = GradientFill | HatchFill | SolidFill | TextureFill | _Fill
+
+  interface _Fill
+    def fill: (magick_image image_obj) -> void
+  end
+
+  VERSION: String
+  MIN_RUBY_VERSION: String
+  MIN_IM_VERSION: String
+
+  QuantumRange: Integer
+  MAGICKCORE_QUANTUM_DEPTH: Integer
+  OpaqueAlpha: Integer
+  TransparentAlpha: Integer
+
+  IMAGEMAGICK_VERSION: String
+  Magick_version: String
+  Long_version: String
+  Magick_features: String
+
+  def self.formats: () -> Hash[String, String]
+                  | () { (String, String) -> void } -> self
+  def self.colors: () { (Color) -> void } -> self
+                 | () -> Array[Color]
+  def self.fonts: () { (Font) -> void } -> self
+                | () -> Array[Font]
+  def self.init_formats: () -> Hash[String, String]
+  def self.limit_resource: (interned resource) -> Integer
+                         | (interned resource, int limit) -> Integer
+  def self.set_cache_threshold: (int threshold) -> self
+  def self.set_log_event_mask: (*string args) -> self
+  def self.set_log_format: (string format) -> self
+end

data/sig/rvg/clippath.rbs

@@ -0,0 +1,34 @@
+# -
+# $Id: clippath.rb,v 1.5 2009/02/28 23:52:13 rmagick Exp $
+# Copyright (C) 2009 Timothy P. Hunter
+# +
+module Magick
+  class RVG
+    class ClipPath
+      @clip_path_units: string
+      @content: Content
+
+      include ShapeConstructors
+      include UseConstructors
+      include TextConstructors
+      include Describable
+      include Stylable
+      include Duplicatable
+
+      # Create a clipping path. Within the block create an outline
+      # from one or more paths, basic shapes, text objects, or +use+.
+      # Everything drawn within the outline will be displayed.
+      # Anything drawn outside the outline will not.
+      #
+      # If the clipping path contains a +use+, it
+      # must directly reference path, basic shape, or text objects.
+      #
+      # Attach the clipping path to an object with the :clip_path style.
+      def initialize: (?string clip_path_units) -> void
+                    | (?string clip_path_units) { (ClipPath) -> void } -> void
+
+      # @private
+      def add_primitives: (Utility::GraphicContext gc, untyped _style) -> void
+    end
+  end
+end

data/sig/rvg/container.rbs

@@ -0,0 +1,78 @@
+# -
+# $Id: container.rb,v 1.5 2009/02/28 23:52:13 rmagick Exp $
+# Copyright (C) 2009 Timothy P. Hunter
+# +
+module Magick
+  class RVG
+    # Content is simply an Array with a deep_copy method.
+    # When unit-testing, it also has a deep_equal method.
+    # @private
+    class Content < Array[untyped]
+      include _Duplicatable
+    end
+
+    # Define a collection of shapes, text, etc. that can be reused.
+    # Group objects are _containers_. That is, styles and transforms defined
+    # on the group are used by contained objects such as shapes, text, and
+    # nested groups unless overridden by a nested container or the object itself.
+    # Groups can be reused with the RVG::UseConstructors#use method.
+    # Create groups within
+    # containers with the RVG::StructureConstructors#g method.
+    #
+    # Example:
+    #   # All elements in the group will be translated by 50 in the
+    #   # x-direction and 10 in the y-direction.
+    #   rvg.g.translate(50, 10).styles(:stroke=>'red',:fill=>'none') do |grp|
+    #       # The line will be red.
+    #       grp.line(10,10, 20,20)
+    #       # The circle will be blue.
+    #       grp.circle(10, 20, 20).styles(:stroke=>'blue')
+    #   end
+    class Group
+      @content: Content
+
+      include Stylable
+      include Transformable
+      include Embellishable
+      include Describable
+      include Duplicatable
+
+      def initialize: () -> void
+                    | () { (Group) -> void } -> void
+
+      # @private
+      def add_primitives: (Utility::GraphicContext gc) -> void
+
+      # Translate container according to #use arguments
+      # @private
+      def ref: (magick_real x, magick_real y, untyped _width, untyped _height) -> void
+
+      # Append an arbitrary object to the group's content. Called
+      # by #use to insert a non-container object into a group.
+      # @private
+      def <<: (_Duplicatable obj) -> void
+    end
+
+    # A Use object allows the re-use of RVG and RVG::Group
+    # objects within a container. Create a Use object with the
+    # RVG::UseConstructors#use method.
+    class Use
+      @element: Group
+
+      include Stylable
+      include Transformable
+      include Duplicatable
+
+      # In a container, Use objects are created indirectly via the
+      # RVG::UseConstructors#use method.
+      # The +x+ and +y+ arguments
+      # can be used to specify an additional translation for
+      # the group. The +width+ and +height+ arguments specify
+      # a width and height for referenced RVG objects.
+      def initialize: (_Duplicatable element, ?magick_real x, ?magick_real y, ?magick_real? width, ?magick_real? height) -> void
+
+      # @private
+      def add_primitives: (Utility::GraphicContext gc) -> void
+    end
+  end
+end

data/sig/rvg/deep_equal.rbs

@@ -0,0 +1,48 @@
+module Magick
+  class RVG
+    interface _DeepEqual
+      def deep_equal: (untyped other) -> bool
+    end
+    class PathData
+      include _DeepEqual
+    end
+
+    class Styles
+      include _DeepEqual
+    end
+
+    class Transforms
+      include _DeepEqual
+    end
+
+    class Shape
+      include _DeepEqual
+    end
+
+    class TextBase
+      include _DeepEqual
+    end
+
+    class Image
+      include _DeepEqual
+    end
+
+    class Group
+      include _DeepEqual
+    end
+
+    class Content
+      include _DeepEqual
+    end
+
+    class Use
+      include _DeepEqual
+    end
+
+    class ClipPath
+      include _DeepEqual
+    end
+
+    include _DeepEqual
+  end
+end

data/sig/rvg/describable.rbs

@@ -0,0 +1,30 @@
+module Magick
+  class RVG
+    # -
+    # Corresponds to SVG's Description.class
+    # +
+    # This module defines a number of metadata attributes.
+    module Describable
+      # Sets the object description
+      attr_writer desc: interned
+
+      # Sets the object title
+      attr_writer title: interned
+
+      # Sets the object metadata
+      attr_writer metadata: interned
+
+      # Returns the title of this object. The RVG object title is stored as
+      # the 'title' property on the image
+      def title: () -> String
+
+      # Returns the description of this object. The RVG object description is
+      # stored as the 'desc' property on the image
+      def desc: () -> String
+
+      # Returns additional metadata of this object. The RVG object metadata
+      # are stored as the 'metadata' property on the image
+      def metadata: () -> String
+    end
+  end
+end

data/sig/rvg/embellishable.rbs

@@ -0,0 +1,226 @@
+module Magick
+  class RVG
+    # Parent class of Circle, Ellipse, Text, etc.
+    # @private
+    class Shape
+      include Stylable
+      include Transformable
+      include Duplicatable
+
+      # Each shape can have its own set of transforms and styles.
+      def add_primitives: (Utility::GraphicContext gc) -> void
+    end
+
+    class Circle < Shape
+      @primitive: Symbol
+      @args: Array[Float]
+
+      # Define a circle with radius +r+ and centered at [<tt>cx</tt>, <tt>cy</tt>].
+      # Use the RVG::ShapeConstructors#circle method to create Circle objects in a container.
+      def initialize: (magick_real r, ?magick_real cx, ?magick_real cy) -> void
+    end
+
+    class Ellipse < Shape
+      @primitive: Symbol
+      @args: Array[Integer | Float]
+
+      # Define an ellipse with a center at [<tt>cx</tt>, <tt>cy</tt>], a horizontal radius +rx+
+      # and a vertical radius +ry+.
+      # Use the RVG::ShapeConstructors#ellipse method to create Ellipse objects in a container.
+      def initialize: (magick_real rx, magick_real ry, ?magick_real cx, ?magick_real cy) -> void
+    end
+
+    class Line < Shape
+      @primitive: Symbol
+      @args: Array[Integer | Float]
+
+      # Define a line from [<tt>x1</tt>, <tt>y1</tt>] to [<tt>x2</tt>, <tt>y2</tt>].
+      # Use the RVG::ShapeConstructors#line method to create Line objects in a container.
+      def initialize: (?magick_real x1, ?magick_real y1, ?magick_real x2, ?magick_real y2) -> void
+    end
+
+    class Path < Shape
+      @primitive: Symbol
+      @args: Array[String]
+
+      # Define an SVG path. The argument can be either a path string
+      # or a PathData object.
+      # Use the RVG::ShapeConstructors#path method to create Path objects in a container.
+      def initialize: (interned path) -> void
+    end
+
+    class Rect < Shape
+      @primitive: Symbol
+      @args: Array[Float]
+
+      # Define a width x height rectangle. The upper-left corner is at [<tt>x</tt>, <tt>y</tt>].
+      # If either <tt>width</tt> or <tt>height</tt> is 0, the rectangle is not rendered.
+      # Use the RVG::ShapeConstructors#rect method to create Rect objects in a container.
+      def initialize: (magick_real width, magick_real height, ?magick_real x, ?magick_real y) -> void
+
+      # Specify optional rounded corners for a rectangle. The arguments
+      # are the x- and y-axis radii. If y is omitted it defaults to x.
+      def round: (magick_real rx, ?magick_real? ry) -> self
+    end
+
+    class PolyShape < Shape
+      def polypoints: (Array[magick_real] points) -> Array[Float?]
+    end
+
+    class Polygon < PolyShape
+      @primitive: Symbol
+      @args: Array[Float]
+
+      # Draws a polygon. The arguments are [<tt>x</tt>, <tt>y</tt>] pairs that
+      # define the points that make up the polygon. At least two
+      # points must be specified. If the last point is not the
+      # same as the first, adds an additional point to close
+      # the polygon.
+      # Use the RVG::ShapeConstructors#polygon method to create Polygon objects in a container.
+      def initialize: (*magick_real points) -> void
+    end
+
+    class Polyline < PolyShape
+      @primitive: Symbol
+      @args: Array[Float]
+
+      # Draws a polyline. The arguments are [<tt>x</tt>, <tt>y</tt>] pairs that
+      # define the points that make up the polyline. At least two
+      # points must be specified.
+      # Use the RVG::ShapeConstructors#polyline method to create Polyline objects in a container.
+      def initialize: (*magick_real points) -> void
+    end
+
+    class Image
+      @align: String
+      @vbx_width: Integer
+      @vbx_height: Integer
+      @meet_or_slice: String
+      @image: Magick::Image
+      @x: Float
+      @y: Float
+      @width: Float
+      @height: Float
+
+      include Stylable
+      include Transformable
+      include Describable
+      include PreserveAspectRatio
+      include Duplicatable
+
+      private
+
+      def align_to_viewport: (real scale) -> [Numeric?, Numeric?]
+      def add_composite_primitive: (Utility::GraphicContext gc) -> void
+      def init_viewbox: () -> void
+
+      public
+
+      # Composite a raster image in the viewport defined by [x,y] and
+      # +width+ and +height+.
+      # Use the RVG::ImageConstructors#image method to create Text objects in a container.
+      def initialize: (Magick::Image image, ?magick_real? width, ?magick_real? height, ?magick_real x, ?magick_real y) -> void
+
+      # @private
+      def add_primitives: (Utility::GraphicContext gc) -> void
+    end
+
+    # Methods that construct basic shapes within a container
+    module ShapeConstructors
+      # Draws a circle whose center is [<tt>cx</tt>, <tt>cy</tt>] and radius is +r+.
+      def circle: (magick_real r, ?magick_real cx, ?magick_real cy) -> Circle
+
+      # Draws an ellipse whose center is [<tt>cx</tt>, <tt>cy</tt>] and having
+      # a horizontal radius +rx+ and vertical radius +ry+.
+      def ellipse: (magick_real rx, magick_real ry, ?magick_real cx, ?magick_real cy) -> Ellipse
+
+      # Draws a line from [<tt>x1</tt>, <tt>y1</tt>] to  [<tt>x2</tt>, <tt>y2</tt>].
+      def line: (?magick_real x1, ?magick_real y1, ?magick_real x2, ?magick_real y2) -> Line
+
+      # Draws a path defined by an SVG path string or a PathData
+      # object.
+      def path: (interned path) -> Path
+
+      # Draws a rectangle whose upper-left corner is [<tt>x</tt>, <tt>y</tt>] and
+      # with the specified +width+ and +height+. Unless otherwise
+      # specified the rectangle has square corners. Returns a
+      # Rectangle object.
+      #
+      # Draw a rectangle with rounded corners by calling the #round
+      # method on the Rectangle object. <tt>rx</tt> and <tt>ry</tt> are
+      # the corner radii in the x- and y-directions. For example:
+      #   canvas.rect(width, height, x, y).round(8, 6)
+      # If <tt>ry</tt> is omitted it defaults to <tt>rx</tt>.
+      def rect: (magick_real width, magick_real height, ?magick_real x, ?magick_real y) -> Rect
+
+      # Draws a polygon. The arguments are [<tt>x</tt>, <tt>y</tt>] pairs that
+      # define the points that make up the polygon. At least two
+      # points must be specified. If the last point is not the
+      # same as the first, adds an additional point to close
+      # the polygon.
+      def polygon: (*magick_real points) -> Polygon
+
+      # Draws a polyline. The arguments are [<tt>x</tt>, <tt>y</tt>] pairs that
+      # define the points that make up the polyline. At least two
+      # points must be specified.
+      def polyline: (*magick_real points) -> Polyline
+    end
+
+    # Methods that reference ("use") other drawable objects within a container
+    module UseConstructors
+      # Reference an object to be inserted into the container's
+      # content. [<tt>x</tt>,<tt>y</tt>] is the offset from the upper-left
+      # corner. If the argument is an RVG or Image object and +width+ and +height+
+      # are specified, these values will override the +width+ and +height+
+      # attributes on the argument.
+      def use: (_Duplicatable obj, ?magick_real x, ?magick_real y, ?magick_real? width, ?magick_real? height) -> Use
+    end
+
+    # Methods that construct container objects within a container
+    module StructureConstructors
+      # Establishes a new viewport. [<tt>x</tt>, <tt>y</tt>] is the coordinate of the
+      # upper-left corner within the containing viewport. This is a
+      # _container_ method. Styles and
+      # transforms specified on this object will be used by objects
+      # contained within, unless overridden by an inner container or
+      # the contained object itself.
+      def rvg: (magick_real cols, magick_real rows, ?magick_real x, ?magick_real y) -> RVG
+             | (magick_real cols, magick_real rows, ?magick_real x, ?magick_real y) { (RVG) -> void } -> RVG
+
+      # Defines a group.
+      #
+      # This method constructs a new
+      # Group _container_ object. The styles and
+      # transforms specified on this object will be used by objects
+      # contained within, unless overridden by an inner container or
+      # the contained object itself.
+      # Define grouped elements by calling RVG::Embellishable
+      # methods within the associated block.
+      def g: () -> Group
+           | { (Group) -> void } -> Group
+    end
+
+    # Methods that construct raster image objects within a container
+    module ImageConstructors
+      # Composite a raster image at [<tt>x</tt>,<tt>y</tt>]
+      # in a viewport of the specified <tt>width</tt> and <tt>height</tt>.
+      # If not specified, the width and height are the width and height
+      # of the image. Use the RVG::PreserveAspectRatio#preserve_aspect_ratio method to
+      # control the placement and scaling of the image within the
+      # viewport. By default, the image is scaled to fit inside the
+      # viewport and centered within the viewport.
+      def image: (Magick::Image image, ?magick_real? width, ?magick_real? height, ?magick_real x, ?magick_real y) -> Image
+    end
+
+    # Methods that create shapes, text, and other drawable objects
+    # within container objects such as ::Magick::RVG and
+    # ::Magick::RVG::Group
+    module Embellishable
+      include StructureConstructors
+      include ShapeConstructors
+      include TextConstructors
+      include UseConstructors
+      include ImageConstructors
+    end
+  end
+end

data/sig/rvg/misc.rbs

@@ -0,0 +1,145 @@
+# $Id: misc.rb,v 1.17 2010/03/21 01:43:01 baror Exp $
+# Copyright (C) 2009 Timothy P. Hunter
+module Magick
+  class RVG
+    # This is a standard deep_copy method that is used in most classes.
+    # Thanks to Robert Klemme.
+    module Duplicatable
+      include _Duplicatable
+    end
+
+    # Convert an array of method arguments to Float objects. If any
+    # cannot be converted, raise ArgumentError and issue a message.
+    def self.fmsg: (*untyped args) -> String
+
+    def self.convert_to_float: (*(magick_real | Symbol) args) -> Array[Float?]
+    def self.convert_one_to_float: (magick_real arg) -> Float
+  end
+end
+
+module Magick
+  class RVG
+    class Utility
+      class TextStrategy
+        @ctx: GraphicContext
+
+        def initialize: (GraphicContext context) -> void
+        def enquote: (String text) -> String
+        def glyph_metrics: (Integer | Float glyph_orientation, string glyph) -> [Integer | Float, Integer | Float]
+        def text_rel_coords: (string text) -> [Array[Integer | Float], Array[Integer | Float]]
+        def shift_baseline: (Integer | Float glyph_orientation, string glyph) -> (Integer | Float)
+        def render_glyph: (Integer | Float glyph_orientation, magick_real x, magick_real y, String glyph) -> void
+      end
+
+      class LRTextStrategy < TextStrategy
+        @word_space: Integer | Float
+
+        def get_word_spacing: () -> [Integer | Float, 0]
+        def get_letter_spacing: (string glyph) -> [Integer | Float, Integer | Float]
+        def render: (Integer | Float x, Integer | Float y, string text) -> [Integer | Float, 0]
+      end
+
+      class RLTextStrategy < TextStrategy
+        def render: (untyped _x, untyped _y, untyped _text) -> untyped
+      end
+
+      class TBTextStrategy < TextStrategy
+        @word_space: Integer | Float
+
+        def get_word_spacing: () -> [0, Integer | Float]
+        def get_letter_spacing: (string glyph) -> [Integer | Float, Integer | Float]
+        def render: (Integer | Float x, Integer | Float y, string text) -> [0, Integer | Float]
+      end
+
+      # Handle "easy" text
+      class DefaultTextStrategy < TextStrategy
+        def render: (Integer | Float x, Integer | Float y, String text) -> [(Integer | Float)?, 0]
+      end
+    end
+  end
+end
+
+module Magick
+  class RVG
+    class Utility
+      class TextAttributes
+        def initialize: () -> void
+        def push: () -> void
+        def pop: () -> void
+        def set_affine: (real sx, real rx, real ry, real sy, real tx, real ty) -> void
+        def affine: () -> Magick::AffineMatrix
+        def baseline_shift: () -> Symbol
+        def baseline_shift=: (interned | real value) -> Symbol
+        def text_anchor: () -> Symbol
+        def text_anchor=: (Symbol anchor) -> Symbol
+        def glyph_orientation_vertical: () -> (Integer | Float)
+        def glyph_orientation_vertical=: (Integer | Float angle) -> (Integer | Float)
+        def glyph_orientation_horizontal: () -> (Integer | Float)
+        def glyph_orientation_horizontal=: (Integer | Float angle) -> (Integer | Float)
+        def letter_spacing: () -> (Integer | Float)
+        def letter_spacing=: (Integer | Float value) -> (Integer | Float)
+        def non_default?: () -> bool
+        def word_spacing: () -> (Integer | Float)
+        def word_spacing=: (Integer | Float value) -> (Integer | Float)
+        def writing_mode: () -> String
+        def writing_mode=: (String mode) -> String
+      end
+
+      class GraphicContext
+        @rx: Integer | Float
+        @sx: Integer | Float
+        @tx: Integer | Float
+        @gc: Magick::Draw
+        @shadow: Array[Magick::Draw]
+        @text_attrs: TextAttributes
+        @ry: Integer | Float
+        @sy: Integer | Float
+        @ty: Integer | Float
+
+        # The methods of Magick::Draw class can be called via method_missing
+        include Magick::_DrawCommonMethods
+
+        attr_reader gc: Magick::Draw
+        attr_reader text_attrs: TextAttributes
+
+        private
+
+        def init_matrix: () -> void
+        def concat_matrix: () -> void
+
+        public
+
+        def self.degrees_to_radians: (real deg) -> Float
+
+        def initialize: () -> void
+        def affine: (magick_real sx, magick_real rx, magick_real ry, magick_real sy, magick_real tx, magick_real ty) -> nil
+                  | ...
+        def baseline_shift: (String | real value) -> nil
+        def font: (string name) -> nil
+        def font_family: (string name) -> nil
+        def font_size: (magick_real points) -> nil
+        def font_stretch: (interned stretch) -> nil
+        def font_style: (interned style) -> nil
+        def font_weight: (interned | int weight) -> nil
+        def glyph_orientation_horizontal: (magick_real deg) -> nil
+        def glyph_orientation_vertical: (magick_real deg) -> nil
+        def inspect: () -> String
+        def letter_spacing: (magick_real value) -> nil
+        def push: () -> nil
+        def pop: () -> nil
+        def rotate: (magick_real degrees) -> nil
+        def scale: (magick_real sx, magick_real sy) -> nil
+        def shadow: () -> Magick::Draw?
+        def skewX: (magick_real degrees) -> nil
+        def skewY: (magick_real degrees) -> nil
+        def stroke_width: (magick_real width) -> nil
+        def text: (magick_real x, magick_real y, string text) -> void
+        def text_anchor: (interned anchor) -> nil
+        def text_decoration: (interned decoration) -> nil
+        def translate: (magick_real tx, magick_real ty) -> nil
+        def word_spacing: (magick_real value) -> nil
+        def writing_mode: (String mode) -> nil
+      end
+    end
+  end
+end

data/sig/rvg/paint.rbs

@@ -0,0 +1,55 @@
+module Magick
+  class RVG
+    class Pattern
+      @width: Float
+      @height: Float
+      @x: Float
+      @y: Float
+      @content: Content
+
+      include StructureConstructors
+      include UseConstructors
+      include ShapeConstructors
+      include TextConstructors
+      include ImageConstructors
+      include Stretchable
+      include Duplicatable
+      include Stylable
+
+      # Return upper-left corner, width, height of viewport in user coordinates.
+      # Usually these are the values specified when the Pattern object is
+      # created, but they can be changed by a call to the viewbox method.
+      attr_reader x: Float
+
+      # Return upper-left corner, width, height of viewport in user coordinates.
+      # Usually these are the values specified when the Pattern object is
+      # created, but they can be changed by a call to the viewbox method.
+      attr_reader y: Float
+
+      # Return upper-left corner, width, height of viewport in user coordinates.
+      # Usually these are the values specified when the Pattern object is
+      # created, but they can be changed by a call to the viewbox method.
+      attr_reader width: Float
+
+      # Return upper-left corner, width, height of viewport in user coordinates.
+      # Usually these are the values specified when the Pattern object is
+      # created, but they can be changed by a call to the viewbox method.
+      attr_reader height: Float
+
+      # Create a pattern that can be used with the :fill or :stroke styles.
+      # The +width+ and +height+ arguments define the viewport.
+      # The pattern will be repeated at <tt>x+m*width</tt> and <tt>y+n*height</tt>
+      # offsets.
+      #
+      # Define the pattern in the block.
+      # The pattern can be composed of shapes (rectangle, circles, etc.), text,
+      # raster images and container objects. You can include graphic objects by
+      # referring to them with #use.
+      def initialize: (?magick_real width, ?magick_real height, ?magick_real x, ?magick_real y) -> void
+                    | (?magick_real width, ?magick_real height, ?magick_real x, ?magick_real y) { (Pattern) -> void } -> void
+
+      # @private
+      def add_primitives: (Utility::GraphicContext gc, interned style) -> void
+    end
+  end
+end