rmagick 2.13.2 → 4.2.2

data/lib/rvg/text.rb

@@ -3,185 +3,174 @@
 # Copyright (C) 2009 Timothy P. Hunter
 #++
 # Text-related classes
-
 module Magick
-    class RVG
-
-        # Base class for Tspan, Tref and Text.
-        class TextBase
-            include Stylable
-            include Duplicatable
-
-          private
-
-            def initialize(text, &block)    #:nodoc:
-                super()
-                @text = text.to_s if text
-                @dx = @dy = 0
-                @rotation = 0
-                @tspans = Content.new
-                yield(self) if block_given?
-            end
-
-          public
-
-            # 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(text, x=nil, y=nil)
-                tspan = Tspan.new(text, x, y)
-                tspan.parent = self
-                @tspans << tspan
-                return tspan
-            end
-
-            # Add <tt>x</tt> and <tt>y</tt> to the current text position.
-            def d(x, y=0)
-                @dx, @dy = Magick::RVG.convert_to_float(x, y)
-                yield(self) if block_given?
-                self
-            end
-
-            # Rotate the text about the current text position.
-            def rotate(degrees)
-                @rotation = Magick::RVG.convert_to_float(degrees)[0]
-                yield(self) if block_given?
-                self
-            end
-
-            # We do our own transformations.
-            def add_primitives(gc)  #:nodoc:
-                if @text || @tspans.length > 0
-                    gc.push
-                    x = self.cx + @dx
-                    y = self.cy + @dy
-                    if @rotation != 0
-                        gc.translate(x, y)
-                        gc.rotate(@rotation)
-                        gc.translate(-x, -y)
-                    end
-                    add_style_primitives(gc)
-                    if @text
-                        x2, y2 = gc.text(x, y, @text)
-                        self.cx = x + x2
-                        self.cy = y + y2
-                    end
-                    @tspans.each do |tspan|
-                        tspan.add_primitives(gc)
-                    end
-                    gc.pop
-                end
-            end
-
-        end     # class TextBase
-
-        # Tspan and Tref shared methods - read/update @cx, @cy in parent Text object.
-        module TextLink     #:nodoc:
-
-            def add_primitives(gc)
-                @parent.cx = @x if @x
-                @parent.cy = @y if @y
-                super
-            end
-
-            def cx()
-                @parent.cx
-            end
-
-            def cy()
-                @parent.cy
-            end
-
-            def cx=(x)
-                @parent.cx = x
-            end
-
-            def cy=(y)
-                @parent.cy = y
-            end
-
-        end     # module TextLink
-
-
-        class Tref < TextBase  #:nodoc:
-            include TextLink
-
-            def initialize(obj, x, y, parent)
-                @x, @y = Magick::RVG.convert_to_float(x, y, :allow_nil)
-                super(nil)
-                @tspans << obj
-                @parent = parent
-            end
-
-        end     # class Tref
-
-        class Tspan < TextBase  #:nodoc:
-            include TextLink
-
-            attr_accessor :parent
-
-            # 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(text=nil, x=nil, y=nil, &block)
-                @x, @y = Magick::RVG.convert_to_float(x, y, :allow_nil)
-                super(text, &block)
-            end
-
-        end     # class Tspan
-
-        class Text < TextBase
-
-            attr_accessor :cx, :cy  #:nodoc:
-
-            # 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(x=0, y=0, text=nil, &block)
-                @cx, @cy = Magick::RVG.convert_to_float(x, y)
-                super(text, &block)
-            end
-
-            # 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(obj, x=nil, y=nil)
-                if ! obj.kind_of?(Tspan)
-                    raise ArgumentError, "wrong argument type #{obj.class} (expected Tspan)"
-                end
-                obj = obj.deep_copy
-                obj.parent = self
-                tref = Tref.new(obj, x, y, self)
-                @tspans << tref
-                return tref
-            end
-
-        end     # class Text
-
-
-
-        # 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(x=0, y=0, text=nil, &block)
-                t = Text.new(x, y, text, &block)
-                @content << t
-                return t
-            end
-
-        end     # module TextConstructors
-
-    end # class RVG
+  class RVG
+    # Base class for Tspan, Tref and Text.
+    class TextBase
+      include Stylable
+      include Duplicatable
+
+      private
+
+      def initialize(text)
+        super()
+        @text = text.to_s if text
+        @dx = @dy = 0
+        @rotation = 0
+        @tspans = Content.new
+        yield(self) if block_given?
+      end
+
+      public
+
+      # 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(text, x = nil, y = nil)
+        tspan = Tspan.new(text, x, y)
+        tspan.parent = self
+        @tspans << tspan
+        tspan
+      end
+
+      # Add <tt>x</tt> and <tt>y</tt> to the current text position.
+      def d(x, y = 0)
+        @dx, @dy = Magick::RVG.convert_to_float(x, y)
+        yield(self) if block_given?
+        self
+      end
+
+      # Rotate the text about the current text position.
+      def rotate(degrees)
+        @rotation = Magick::RVG.convert_to_float(degrees)[0]
+        yield(self) if block_given?
+        self
+      end
+
+      # We do our own transformations.
+      # @private
+      def add_primitives(gc)
+        return if !@text && @tspans.empty?
+
+        gc.push
+        x = cx + @dx
+        y = cy + @dy
+        if @rotation != 0
+          gc.translate(x, y)
+          gc.rotate(@rotation)
+          gc.translate(-x, -y)
+        end
+        add_style_primitives(gc)
+        if @text
+          x2, y2 = gc.text(x, y, @text)
+          self.cx = x + x2
+          self.cy = y + y2
+        end
+        @tspans.each do |tspan|
+          tspan.add_primitives(gc)
+        end
+        gc.pop
+      end
+    end # class TextBase
+
+    # Tspan and Tref shared methods - read/update @cx, @cy in parent Text object.
+    # @private
+    module TextLink
+      def add_primitives(gc)
+        @parent.cx = @x if @x
+        @parent.cy = @y if @y
+        super
+      end
+
+      def cx
+        @parent.cx
+      end
+
+      def cy
+        @parent.cy
+      end
+
+      def cx=(x)
+        @parent.cx = x
+      end
+
+      def cy=(y)
+        @parent.cy = y
+      end
+    end # module TextLink
+
+    # @private
+    class Tref < TextBase
+      include TextLink
+
+      def initialize(obj, x, y, parent)
+        @x, @y = Magick::RVG.convert_to_float(x, y, :allow_nil)
+        super(nil)
+        @tspans << obj
+        @parent = parent
+      end
+    end # class Tref
+
+    # @private
+    class Tspan < TextBase
+      include TextLink
+
+      attr_accessor :parent
+
+      # 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(text = nil, x = nil, y = nil, &block)
+        @x, @y = Magick::RVG.convert_to_float(x, y, :allow_nil)
+        super(text, &block)
+      end
+    end # class Tspan
+
+    class Text < TextBase
+      # @private
+      attr_accessor :cx, :cy
+
+      # 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(x = 0, y = 0, text = nil, &block)
+        @cx, @cy = Magick::RVG.convert_to_float(x, y)
+        super(text, &block)
+      end
+
+      # 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(obj, x = nil, y = nil)
+        raise ArgumentError, "wrong argument type #{obj.class} (expected Tspan)" unless obj.is_a?(Tspan)
+
+        obj = obj.deep_copy
+        obj.parent = self
+        tref = Tref.new(obj, x, y, self)
+        @tspans << tref
+        tref
+      end
+    end # class Text
+
+    # 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(x = 0, y = 0, text = nil, &block)
+        t = Text.new(x, y, text, &block)
+        @content << t
+        t
+      end
+    end # module TextConstructors
+  end # class RVG
 end # module Magick

data/lib/rvg/transformable.rb

@@ -2,132 +2,126 @@
 # $Id: transformable.rb,v 1.5 2009/02/28 23:52:28 rmagick Exp $
 # Copyright (C) 2009 Timothy P. Hunter
 #++
-
 module Magick
-    class RVG
-
-        # Transforms is an Array with a deep_copy method.
-        # During unit-testing it also has a deep_equal method.
-        class Transforms < Array        #:nodoc:
-
-            def deep_copy(h=nil)
-                copy = self.class.new
-                each { |transform| copy << [transform[0], transform[1].dup] }
-                return copy
-            end
-
-        end     # class Transform
-
-        # 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
-
-          private
-
-            # Apply transforms in the same order they were specified!
-            def add_transform_primitives(gc)
-                @transforms.each { |transform| gc.__send__(transform[0], *transform[1]) }
-            end
-
-            def initialize(*args, &block)
-                super()
-                @transforms = Transforms.new
-            end
-
-          public
-
-            # Applies the transformation matrix [sx, rx, ry, sy, tx, ty]
-            def matrix(sx, rx, ry, sy, tx, ty)
-                begin
-                    @transforms << [:affine, [Float(sx), Float(rx), Float(ry), Float(sy), Float(tx), Float(ty)]]
-                rescue ArgumentError
-                    raise ArgumentError, "arguments must be convertable to float (got #{sx.class}, #{rx.class}, #{ry.class}, #{sy.class}, #{sx.class}, #{sx.class}, #{tx.class}, #{ty.class})"
-                end
-                yield(self) if block_given?
-                self
-            end
-
-            # 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(tx, ty=nil)
-                ty ||= tx
-                begin
-                    @transforms << [:translate, [Float(tx), Float(ty)]]
-                rescue ArgumentError
-                    raise ArgumentError, "arguments must be convertable to float (got #{tx.class}, #{ty.class})"
-                end
-                yield(self) if block_given?
-                self
-            end
-
-            # 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(sx, sy=nil)
-                sy ||= sx
-                begin
-                    @transforms << [:scale, [Float(sx), Float(sy)]]
-                rescue ArgumentError
-                    raise ArgumentError, "arguments must be convertable to float (got #{sx.class}, #{sy.class})"
-                end
-                yield(self) if block_given?
-                self
-            end
-
-            # 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(angle, *args)
-                begin
-                    case args.length
-                        when 0
-                            @transforms << [:rotate, [Float(angle)]]
-                        when 2
-                            cx, cy = Float(args[0]), Float(args[1])
-                            @transforms << [:translate, [cx, cy]]
-                            @transforms << [:rotate, [angle]]
-                            @transforms << [:translate, [-cx, -cy]]
-                        else
-                            raise ArgumentError, "wrong number of arguments (#{args.length} for 1 or 3)"
-                    end
-                rescue ArgumentError
-                    raise ArgumentError, "arguments must be convertable to float (got #{[angle, *args].collect {|a| a.class}.join(', ')})"
-                end
-                yield(self) if block_given?
-                self
-            end
-
-            # Skew the X-axis by <tt>angle</tt> degrees.
-            def skewX(angle)
-                begin
-                    @transforms << [:skewx, [Float(angle)]]
-                rescue ArgumentError
-                    raise ArgumentError, "argument must be convertable to float (got #{angle.class})"
-                end
-                yield(self) if block_given?
-                self
-            end
-
-            # Skew the Y-axis by <tt>angle</tt> degrees.
-            def skewY(angle)
-                begin
-                    @transforms << [:skewy, [Float(angle)]]
-                rescue ArgumentError
-                    raise ArgumentError, "argument must be convertable to float (got #{angle.class})"
-                end
-                yield(self) if block_given?
-                self
-            end
-
-        end     # module Transformable
-
-    end # class RVG
+  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
+      def deep_copy(_h = nil)
+        copy = self.class.new
+        each { |transform| copy << [transform[0], transform[1].dup] }
+        copy
+      end
+    end # class Transform
+
+    # 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
+      private
+
+      # Apply transforms in the same order they were specified!
+      def add_transform_primitives(gc)
+        @transforms.each { |transform| gc.__send__(transform[0], *transform[1]) }
+      end
+
+      def initialize(*_args)
+        super()
+        @transforms = Transforms.new
+      end
+
+      public
+
+      # Applies the transformation matrix [sx, rx, ry, sy, tx, ty]
+      def matrix(sx, rx, ry, sy, tx, ty)
+        begin
+          @transforms << [:affine, [Float(sx), Float(rx), Float(ry), Float(sy), Float(tx), Float(ty)]]
+        rescue ArgumentError
+          raise ArgumentError, "arguments must be convertable to float (got #{sx.class}, #{rx.class}, #{ry.class}, #{sy.class}, #{sx.class}, #{sx.class}, #{tx.class}, #{ty.class})"
+        end
+        yield(self) if block_given?
+        self
+      end
+
+      # 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(tx, ty = nil)
+        ty ||= tx
+        begin
+          @transforms << [:translate, [Float(tx), Float(ty)]]
+        rescue ArgumentError
+          raise ArgumentError, "arguments must be convertable to float (got #{tx.class}, #{ty.class})"
+        end
+        yield(self) if block_given?
+        self
+      end
+
+      # 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(sx, sy = nil)
+        sy ||= sx
+        begin
+          @transforms << [:scale, [Float(sx), Float(sy)]]
+        rescue ArgumentError
+          raise ArgumentError, "arguments must be convertable to float (got #{sx.class}, #{sy.class})"
+        end
+        yield(self) if block_given?
+        self
+      end
+
+      # 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(angle, *args)
+        begin
+          case args.length
+          when 0
+            @transforms << [:rotate, [Float(angle)]]
+          when 2
+            cx = Float(args[0])
+            cy = Float(args[1])
+            @transforms << [:translate, [cx, cy]]
+            @transforms << [:rotate, [angle]]
+            @transforms << [:translate, [-cx, -cy]]
+          else
+            raise ArgumentError, "wrong number of arguments (#{args.length} for 1 or 3)"
+          end
+        rescue ArgumentError
+          raise ArgumentError, "arguments must be convertable to float (got #{[angle, *args].map(&:class).join(', ')})"
+        end
+        yield(self) if block_given?
+        self
+      end
+
+      # Skew the X-axis by <tt>angle</tt> degrees.
+      def skewX(angle)
+        begin
+          @transforms << [:skewx, [Float(angle)]]
+        rescue ArgumentError
+          raise ArgumentError, "argument must be convertable to float (got #{angle.class})"
+        end
+        yield(self) if block_given?
+        self
+      end
+
+      # Skew the Y-axis by <tt>angle</tt> degrees.
+      def skewY(angle)
+        begin
+          @transforms << [:skewy, [Float(angle)]]
+        rescue ArgumentError
+          raise ArgumentError, "argument must be convertable to float (got #{angle.class})"
+        end
+        yield(self) if block_given?
+        self
+      end
+    end # module Transformable
+  end # class RVG
 end # module Magick
-