rmagick-windows 2.16.1

data/lib/rvg/stretchable.rb

@@ -0,0 +1,165 @@
+#--
+# $Id: stretchable.rb,v 1.7 2009/02/28 23:52:28 rmagick Exp $
+# Copyright (C) 2009 Timothy P. Hunter
+#++
+module Magick
+  class RVG
+    module PreserveAspectRatio
+      #--
+      #   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(align, meet_or_slice='meet')
+        @align = align.to_s
+        if @align != 'none'
+          m = /\A(xMin|xMid|xMax)(YMin|YMid|YMax)\z/.match(@align)
+          fail(ArgumentError, "unknown alignment specifier: #{@align}") unless m
+        end
+
+        if meet_or_slice
+          meet_or_slice = meet_or_slice.to_s.downcase
+          if meet_or_slice == 'meet' || meet_or_slice == 'slice'
+            @meet_or_slice = meet_or_slice
+          else
+            fail(ArgumentError, "specifier must be `meet' or `slice' (got #{meet_or_slice})")
+          end
+        end
+        yield(self) if block_given?
+        self
+      end
+    end     # module PreserveAspectRatio
+
+    # The methods in this module describe the user-coordinate space.
+    # RVG and Pattern objects are stretchable.
+    module Stretchable
+      private
+
+      # Scale to fit
+      def set_viewbox_none(width, height)
+        sx = 1.0
+        sy = 1.0
+
+        if @vbx_width
+          sx = width / @vbx_width
+        end
+        if @vbx_height
+          sy = height / @vbx_height
+        end
+
+        [sx, sy]
+      end
+
+      # Use align attribute to compute x- and y-offset from viewport's upper-left corner.
+      def align_to_viewport(width, height, sx, sy)
+        tx = case @align
+             when /\AxMin/
+               0
+             when NilClass, /\AxMid/
+               (width - @vbx_width*sx) / 2.0
+             when /\AxMax/
+               width - @vbx_width*sx
+        end
+
+        ty = case @align
+             when /YMin\z/
+               0
+             when NilClass, /YMid\z/
+               (height - @vbx_height*sy) / 2.0
+             when /YMax\z/
+               height - @vbx_height*sy
+        end
+        [tx, ty]
+      end
+
+      # Scale to smaller viewbox dimension
+      def set_viewbox_meet(width, height)
+        sx = sy = [width / @vbx_width, height / @vbx_height].min
+        [sx, sy]
+      end
+
+      # Scale to larger viewbox dimension
+      def set_viewbox_slice(width, height)
+        sx = sy = [width / @vbx_width, height / @vbx_height].max
+        [sx, sy]
+      end
+
+      # Establish the viewbox as necessary
+      def add_viewbox_primitives(width, height, gc)
+        @vbx_width  ||= width
+        @vbx_height ||= height
+        @vbx_x ||= 0.0
+        @vbx_y ||= 0.0
+
+        if @align == 'none'
+          sx, sy = set_viewbox_none(width, height)
+          tx = 0
+          ty = 0
+        elsif @meet_or_slice == 'meet'
+          sx, sy = set_viewbox_meet(width, height)
+          tx, ty = align_to_viewport(width, height, sx, sy)
+        else
+          sx, sy = set_viewbox_slice(width, height)
+          tx, ty = align_to_viewport(width, height, sx, sy)
+        end
+
+        # Establish clipping path around the current viewport
+        name = __id__.to_s
+        gc.define_clip_path(name) do
+          gc.path("M0,0 l#{width},0 l0,#{height} l-#{width},0 l0,-#{height}z")
+        end
+
+        gc.clip_path(name)
+        # Add a non-scaled translation if meet or slice
+        gc.translate(tx, ty) if tx.abs > 1.0e-10 || ty.abs > 1.0e-10
+        # Scale viewbox as necessary
+        gc.scale(sx, sy) if sx != 1.0 || sy != 1.0
+        # Add a scaled translation if non-0 origin
+        gc.translate(-@vbx_x, -@vbx_y) if @vbx_x.abs != 0.0 || @vbx_y.abs != 0
+      end
+
+      def initialize(*args, &block)
+        super()
+        @vbx_x, @vbx_y, @vbx_width, @vbx_height = nil
+        @meet_or_slice = 'meet'
+        @align = nil
+      end
+
+      public
+
+      include PreserveAspectRatio
+
+      # 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(x, y, width, height)
+        begin
+          @vbx_x = Float(x)
+          @vbx_y = Float(y)
+          @vbx_width = Float(width)
+          @vbx_height = Float(height)
+        rescue ArgumentError
+          raise ArgumentError, "arguments must be convertable to float (got #{x.class}, #{y.class}, #{width.class}, #{height.class})"
+        end
+        fail(ArgumentError, "viewbox width must be > 0 (#{width} given)") unless width >= 0
+        fail(ArgumentError, "viewbox height must be > 0 (#{height} given)") unless height >= 0
+
+        # return the user-coordinate space attributes if defined
+        class << self
+          unless defined? @redefined
+          @redefined = true
+          define_method(:x) { @vbx_x }
+          define_method(:y) { @vbx_y }
+          define_method(:width) { @vbx_width}
+          define_method(:height) { @vbx_height }
+          end
+        end
+
+        yield(self) if block_given?
+        self
+      end
+    end # module Stretchable
+  end # class RVG
+end # module Magick

data/lib/rvg/stylable.rb

@@ -0,0 +1,116 @@
+#--
+# $Id: stylable.rb,v 1.7 2009/02/28 23:52:28 rmagick Exp $
+# Copyright (C) 2009 Timothy P. Hunter
+#++
+module Magick
+  class RVG
+    #:stopdoc:
+    STYLES = [:clip_path, :clip_rule, :fill, :fill_opacity, :fill_rule, :font,
+          :font_family, :font_size, :font_stretch, :font_style, :font_weight,
+          :opacity, :stroke, :stroke_dasharray, :stroke_dashoffset, :stroke_linecap,
+          :stroke_linejoin, :stroke_miterlimit, :stroke_opacity, :stroke_width,
+          :text_anchor, :text_decoration,
+          :glyph_orientation_vertical, :glyph_orientation_horizontal,
+          :letter_spacing, :word_spacing, :baseline_shift, :writing_mode]
+
+    Styles = Struct.new(*STYLES)
+
+    # Styles is a Struct class with a couple of extra methods
+    class Styles
+      def set(styles)
+        begin
+          styles.each_pair do |style, value|
+            begin
+              self[style] = value
+            rescue NoMethodError
+              raise ArgumentError, "unknown style `#{style}'"
+            end
+          end
+        rescue NoMethodError
+          raise ArgumentError, "style arguments must be in the form `style => value'"
+        end
+        self
+      end
+
+      # Iterate over the style names. Yield for each style that has a value.
+      def each_value
+        each_pair do |style, value|
+          yield(style, value) if value
+        end
+      end
+
+      # The "usual" deep_copy method doesn't copy a Struct correctly.
+      def deep_copy(h=nil)
+        copy = Styles.new
+        each_pair { |style, value| copy[style] = value }
+        copy
+      end
+    end     # class Styles
+
+    #:startdoc:
+
+    # This module is mixed into classes that can have styles.
+    module Stylable
+      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(gc)
+        @styles.each_value do |style, value|
+          if value.respond_to? :add_primitives
+            value.add_primitives(gc, style)
+          else
+            gc.__send__(style, *value)
+          end
+        end
+      end
+
+      def initialize
+        super
+        @styles = Styles.new
+      end
+
+      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(styles)
+        @styles.set(styles)
+        yield(self) if block_given?
+        self
+      end
+    end     # module Stylable
+  end # class RVG
+end # module Magick

data/lib/rvg/text.rb

@@ -0,0 +1,172 @@
+#--
+# $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
+            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
+                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 = 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
+        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)
+                unless obj.is_a?(Tspan)
+                    fail 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
+                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