rmagick4j 0.3.1-java → 0.3.2-java

data/lib/rvg/stretchable.rb

@@ -0,0 +1,156 @@
+#--
+# $Id: stretchable.rb,v 1.4 2007/01/20 17:39:50 rmagick Exp $
+# Copyright (C) 2007 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)
+                    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
+            # Scale to fit
+            def set_viewbox_none(width, height)
+                sx, sy = 1.0, 1.0
+
+                if @vbx_width
+                    sx = width / @vbx_width
+                end
+                if @vbx_height
+                    sy = height / @vbx_height
+                end
+
+                return [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
+                return [tx, ty]
+            end
+
+            # Scale to smaller viewbox dimension
+            def set_viewbox_meet(width, height)
+                sx = sy = [width / @vbx_width, height / @vbx_height].min
+                return [sx, sy]
+            end
+
+            # Scale to larger viewbox dimension
+            def set_viewbox_slice(width, height)
+                sx = sy = [width / @vbx_width, height / @vbx_height].max
+                return [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, ty = 0, 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
+                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 RVG
+end # module Magick
+

data/lib/rvg/stylable.rb

@@ -0,0 +1,118 @@
+#--
+# $Id: stylable.rb,v 1.4 2007/01/20 17:49:57 rmagick Exp $
+# Copyright (C) 2007 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 }
+                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 RVG
+end # module Magick
+

data/lib/rvg/text.rb

@@ -0,0 +1,187 @@
+#--
+# $Id: text.rb,v 1.5 2007/01/20 17:39:50 rmagick Exp $
+# Copyright (C) 2007 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
+end # module Magick