rmagick 1.7.4 → 1.8.0

data/lib/rvg/stretchable.rb

@@ -0,0 +1,150 @@
+#--
+# $Id: stretchable.rb,v 1.1 2005/03/12 17:02:00 rmagick Exp $
+# Copyright (C) 2005 Timothy P. Hunter
+#++
+
+class Magick::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)
+                raise(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
+                    raise(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.
+    # Only RVG objects are stretchable.
+    module Stretchable
+
+      private
+        def set_viewbox_none(width, height)
+            sx, sy = 1.0, 1.0
+            tx, ty = @vbx_x, @vbx_y
+
+            if @vbx_width
+                sx = width / @vbx_width
+            end
+            if @vbx_height
+                sy = height / @vbx_height
+            end
+
+            return [tx, ty, 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, ty = @vbx_x, @vbx_y
+            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
+            return [tx, ty]
+        end
+
+        # Scale to smaller viewbox dimension
+        def set_viewbox_meet(width, height)
+            sx = sy = [width / @vbx_width, height / @vbx_height].min
+            tx, ty = align_to_viewport(width, height, sx, sy)
+            return [tx, ty, sx, sy]
+        end
+
+        # Scale to larger viewbox dimension
+        def set_viewbox_slice(width, height)
+            sx = sy = [width / @vbx_width, height / @vbx_height].max
+            tx, ty = align_to_viewport(width, height, sx, sy)
+            return [tx, ty, 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'
+                tx, ty, sx, sy = set_viewbox_none(width, height)
+            elsif @meet_or_slice == 'meet'
+                tx, ty, sx, sy = set_viewbox_meet(width, height)
+            else
+                tx, ty, sx, sy = set_viewbox_slice(width, height)
+            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)
+            gc.translate(tx, ty) if (tx.abs > 1.0e-10 || ty.abs > 1.0e-10)
+            gc.scale(sx, sy) if (sx != 1.0 || sy != 1.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
+            raise(ArgumentError, "viewbox width must be > 0 (#{width} given)") unless width >= 0
+            raise(ArgumentError, "viewbox height must be > 0 (#{height} given)") unless height >= 0
+            yield(self) if block_given?
+            self
+        end
+
+    end     # module Stretchable
+
+end     # class Magick::RVG
+

data/lib/rvg/stylable.rb

@@ -0,0 +1,116 @@
+#--
+# $Id: stylable.rb,v 1.1 2005/03/12 17:02:00 rmagick Exp $
+# Copyright (C) 2005 Timothy P. Hunter
+#++
+
+class Magick::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 }
+            return 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:
+        # [: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.
+        # [: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'
+        def styles(styles)
+            @styles.set(styles)
+            yield(self) if block_given?
+            self
+        end
+
+    end     # module Stylable
+
+end     # class Magick::RVG
+

data/lib/rvg/text.rb

@@ -0,0 +1,185 @@
+#--
+# $Id: text.rb,v 1.2 2005/04/23 15:29:47 rmagick Exp $
+# Copyright (C) 2005 Timothy P. Hunter
+#++
+# Text-related classes
+
+class Magick::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 = 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 = 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 = 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 = 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 = 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