dyi 0.0.0

data/lib/dyi/formatter/eps_formatter.rb

@@ -0,0 +1,397 @@
+# -*- encoding: UTF-8 -*-
+
+# Copyright (c) 2009-2011 Sound-F Co., Ltd. All rights reserved.
+#
+# Author:: Mamoru Yuo
+#
+# This file is part of DYI.
+#
+# DYI is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# DYI is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with DYI.  If not, see <http://www.gnu.org/licenses/>.
+
+require 'nkf'
+
+module DYI #:nodoc:
+  module Formatter #:nodoc:
+
+    class EpsFormatter < Base
+
+      def header_comment
+        <<-EOS
+%!PS-Adobe-3.0 EPSF-3.0
+%%CreationDate: #{Time.now.strftime('%a %b %d %H:%M:%S %Y')}
+%%BoundingBox: 0 0 #{@canvas.real_width.to_f('pt').ceil}  #{@canvas.real_height.to_f('pt').ceil}
+%%EndComments
+        EOS
+      end
+
+      def prolog
+        <<-EOS
+%%BeginProlog
+/px { } bind def
+/pt { #{Length.unit_ratio('pt')} mul } bind def
+/cm { #{Length.unit_ratio('cm')} mul } bind def
+/mm { #{Length.unit_ratio('mm')} mul } bind def
+/in { #{Length.unit_ratio('in')} mul } bind def
+/pc { #{Length.unit_ratio('pc')} mul } bind def
+%%EndProlog
+        EOS
+      end
+
+      def footer_comment
+        <<-EOS
+%%EOF
+        EOS
+      end
+
+      def base_transform
+        pt_ratio = 1.quo(Length.unit_ratio('pt'))
+        <<-EOS
+[#{pt_ratio} 0 0 -#{pt_ratio} 0 #{@canvas.real_height * pt_ratio}] concat
+        EOS
+      end
+
+      def puts(io=$>)
+        StringFormat.set_default_formats(:color=>['%.3f %.3f %.3f', true], :length=>'0.### U', :coordinate=>'x y') {
+          if @canvas.root_node?
+            io << header_comment
+            io << prolog
+            io << base_transform
+          end
+          @canvas.write_as(self, io)
+          if @canvas.root_node?
+            io << footer_comment
+          end
+        }
+      end
+
+      def write_canvas(canvas, io)
+        canvas.child_elements.each do |element|
+          element.write_as(self, io)
+        end
+      end
+
+      def write_rectangle(shape, io)
+        command_block(io) {
+          transform_path(io, shape)
+          clip_path(io, shape)
+          puts_line(io, 'newpath')
+          puts_line(io, shape.left, shape.top, 'moveto')
+          puts_line(io, shape.width, 0, 'rlineto')
+          puts_line(io, 0, shape.height, 'rlineto')
+          puts_line(io, -shape.width, 0, 'rlineto')
+          puts_line(io, 'closepath')
+          if block_given?
+            yield
+          else
+            fill_current_path(io, shape)
+            stroke_current_path(io, shape)
+          end
+        }
+      end
+
+      def write_circle(shape, io)
+        command_block(io) {
+          transform_path(io, shape)
+          clip_path(io, shape)
+          puts_line(io, 'newpath')
+          puts_line(io, shape.center.x + shape.radius, shape.center.y, 'moveto')
+          puts_line(io, shape.center.x, shape.center.y, shape.radius, 0, 360, 'arc')
+          if block_given?
+            yield
+          else
+            fill_current_path(io, shape)
+            stroke_current_path(io, shape)
+          end
+        }
+      end
+
+      def write_ellipse(shape, io)
+        ratio = shape.radius_x.to_f / shape.radius_y.to_f
+        command_block(io) {
+          transform_path(io, shape)
+          clip_path(io, shape)
+          puts_line(io, 1, 1.0 / ratio, 'scale')
+          puts_line(io, 'newpath')
+          puts_line(io, shape.center.x + shape.radius_x, shape.center.y * ratio, 'moveto')
+          puts_line(io, shape.center.x, shape.center.y * ratio, shape.radius_x, 0, 360, 'arc')
+          if block_given?
+            yield
+          else
+            fill_current_path(io, shape)
+            stroke_current_path(io, shape)
+          end
+        }
+      end
+
+      def write_line(shape, io)
+        command_block(io) {
+          transform_path(io, shape)
+          clip_path(io, shape)
+          puts_line(io, 'newpath')
+          write_lines(io, [shape.start_point, shape.end_point])
+          if block_given?
+            yield
+          else
+            stroke_current_path(io, shape)
+          end
+        }
+      end
+
+      def write_polyline(shape, io)
+        command_block(io) {
+          transform_path(io, shape)
+          clip_path(io, shape)
+          puts_line(io, 'newpath')
+          write_lines(io, shape.points)
+          if block_given?
+            yield
+          else
+            fill_current_path(io, shape)
+            stroke_current_path(io, shape)
+          end
+        }
+      end
+
+      def write_polygon(shape, io)
+        command_block(io) {
+          transform_path(io, shape)
+          clip_path(io, shape)
+          puts_line(io, 'newpath')
+          write_lines(io, shape.points)
+          puts_line(io, 'closepath')
+          if block_given?
+            yield
+          else
+            fill_current_path(io, shape)
+            stroke_current_path(io, shape)
+          end
+        }
+      end
+
+      def write_path(shape, io)
+        command_block(io) {
+          transform_path(io, shape)
+          clip_path(io, shape)
+          puts_line(io, 'newpath')
+          shape.compatible_path_data.each do |cmd|
+            case cmd
+            when Shape::Path::MoveCommand
+              puts_line(io, cmd.point.x, cmd.point.y, cmd.relative? ? 'rmoveto' : 'moveto')
+            when Shape::Path::CloseCommand
+              puts_line(io, 'closepath')
+            when Shape::Path::LineCommand
+              puts_line(io, cmd.point.x, cmd.point.y, cmd.relative? ? 'rlineto' : 'lineto')
+            when Shape::Path::CurveCommand
+              puts_line(io,
+                        cmd.control_point1.x, cmd.control_point1.y,
+                        cmd.control_point2.x, cmd.control_point2.y,
+                        cmd.point.x, cmd.point.y,
+                        cmd.relative? ? 'rcurveto' : 'curveto')
+            else
+              raise TypeError, "unknown command: #{cmd.class}"
+            end
+          end
+          if block_given?
+            yield
+          else
+            fill_current_path(io, shape)
+            stroke_current_path(io, shape)
+          end
+        }
+      end
+
+      def write_text(shape, io)
+        command_block(io) {
+          puts_line(io, '/GothicBBB-Medium-RKSJ-H findfont', shape.font.draw_size, 'scalefont setfont')
+          text = NKF.nkf('-s -W', shape.formated_text).unpack('H*').first
+          case shape.attributes[:text_anchor]
+            when 'middle' then dx = "<#{text}> stringwidth pop -0.5 mul"
+            when 'end' then dx = "<#{text}> stringwidth pop -1 mul"
+            else dx = "0"
+          end
+          case shape.attributes[:alignment_baseline]
+            when 'top' then y = shape.point.y - shape.font_height * 0.85
+            when 'middle' then y = shape.point.y - shape.font_height * 0.35
+            when 'bottom' then y = shape.point.y + shape.font_height * 0.15
+            else y = shape.point.y
+          end
+          puts_line(io, "[ 1 0 0 -1 #{dx}", shape.point.y * 2, '] concat')
+          puts_line(io, shape.point.x, y, 'moveto')
+          puts_line(io, "<#{text}>", 'show')
+        }
+      end
+
+      def write_group(shape, io)
+        command_block(io) {
+          transform_path(io, shape)
+          clip_path(io, shape)
+          shape.child_elements.each do |element|
+            element.write_as(self, io)
+          end
+        } unless shape.child_elements.empty?
+      end
+
+      private
+
+      def puts_line(io, *args) #:nodoc:
+        io << args.flatten.join(' ') << "\n"
+      end
+
+      def command_block(io) #:nodoc:
+        puts_line(io, 'gsave')
+        yield
+        puts_line(io, 'grestore')
+      end
+
+      def stroke_path(io, shape) #:nodoc:
+        cmds = []
+        if shape.respond_to?(:painting) && (attrs = shape.painting)
+          cmds.push([attrs.stroke, 'setrgbcolor']) if attrs.stroke
+          cmds.push([attrs.stroke_width, 'setlinewidth']) if attrs.stroke_width && attrs.stroke_width.to_f > 0
+          cmds.push(['[', attrs.stroke_dasharray, ']', attrs.stroke_dashoffset || 0, 'setdash']) if attrs.stroke_dasharray
+          cmds.push([linecap_to_num(attrs.stroke_linecap), 'setlinecap']) if linecap_to_num(attrs.stroke_linecap)
+          cmds.push([linejoin_to_num(attrs.stroke_linejoin), 'setlinejoin']) if linejoin_to_num(attrs.stroke_linejoin)
+          cmds.push([attrs.stroke_miterlimit, 'setmiterlimit']) if attrs.stroke_miterlimit
+        end
+        return if cmds.empty?
+        command_block(io) {
+          cmds.each do |cmd|
+            puts_line(io, *cmd)
+          end
+          yield
+        }
+      end
+
+      def stroke_current_path(io, shape) #:nodoc:
+        stroke_path(io, shape) {
+          puts_line(io, 'stroke')
+        } if shape.painting.stroke
+      end
+
+      def fill_path(io, shape) #:nodoc:
+        cmds = []
+        if shape.respond_to?(:painting) && (attrs = shape.painting)
+          if attrs.fill
+            if attrs.fill.respond_to?(:write_as)
+              cmds.push(linear_gradiant_commands(shape, attrs.fill))
+            else
+              cmds.push([attrs.fill, 'setrgbcolor'])
+            end
+          end
+        end
+        return if cmds.empty?
+        command_block(io) {
+          cmds.each do |cmd|
+            puts_line(io, *cmd)
+          end
+          yield
+        }
+      end
+
+      def fill_current_path(io, shape) #:nodoc:
+        fill_path(io, shape) {
+          puts_line(io, shape.painting.fill_rule == 'evenodd' ? 'eofill' : 'fill')
+        } if shape.painting.fill
+      end
+
+      def linecap_to_num(linecap) #:nodoc:
+        case linecap
+          when 'butt' then 0
+          when 'round' then 1
+          when 'square' then 2
+        end
+      end
+
+      def linejoin_to_num(linejoin) #:nodoc:
+        case linejoin
+          when 'miter' then 0
+          when 'round' then 1
+          when 'bevel' then 2
+        end
+      end
+
+      def write_lines(io, points) #:nodoc:
+        puts_line(io, points.first.x, points.first.y, 'moveto')
+        points[1..-1].each do |pt|
+          pt = Coordinate.new(pt)
+          puts_line(io, pt.x, pt.y, 'lineto')
+        end
+      end
+
+      def linear_gradiant_commands(shape, lg)
+        x1 = shape.left * (1 - lg.start_point[0]) + shape.right * lg.start_point[0]
+        y1 = shape.top * (1 - lg.start_point[1]) + shape.bottom * lg.start_point[1]
+        x2 = shape.left * (1 - lg.stop_point[0]) + shape.right * lg.stop_point[0]
+        y2 = shape.top * (1 - lg.stop_point[1]) + shape.bottom * lg.stop_point[1]
+
+        last_stop = lg.child_elements.first
+
+        cmds = []
+        if last_stop
+          lg.child_elements[1..-1].each do |g_stop|
+            c1 = last_stop.color
+            c2 = g_stop.color
+            next unless c1 && c2
+            s_x1 = x1 * (1 - last_stop.offset) + x2 * last_stop.offset
+            s_y1 = y1 * (1 - last_stop.offset) + y2 * last_stop.offset
+            s_x2 = x1 * (1 - g_stop.offset) + x2 * g_stop.offset
+            s_y2 = y1 * (1 - g_stop.offset) + y2 * g_stop.offset
+            cmds.push(['<< /PatternType 2 /Shading << /ShadingType 2 /ColorSpace /DeviceRGB'])
+            cmds.push(['/Coords [', s_x1, s_y1, s_x2, s_y2, ']'])
+            cmds.push(['/Function << /FunctionType 2 /Domain [ 0 1 ]'])
+            cmds.push(['/C0 [', c1, ']'])
+            cmds.push(['/C1 [', c2, ']'])
+            cmds.push(['/N 1 >> >> >> matrix makepattern setpattern fill'])
+            current_stop = g_stop
+          end
+        end
+        cmds
+      end
+
+      def transform_path(io, shape) #:nodoc:
+        if shape.respond_to?(:transform) && !(tr = shape.transform).empty?
+          tr.each do |t|
+            case t[0]
+            when :translate
+              puts_line(io, t[1], t[2], 'translate')
+            when :scale
+              puts_line(io, t[1], t[2], 'scale')
+            when :rotate
+              puts_line(io, t[1], t[2], 'rotate')
+            when :skewX
+              tan = Math.tan(t[1] * Math::PI / 180)
+              puts_line(io, '[', 1, 0, tan, 1, 0, 0, ']', 'concat')
+            when :skewY
+              tan = Math.tan(t[1] * Math::PI / 180)
+              puts_line(io, '[', 1, tan, 0, 1, 0, 0, ']', 'concat')
+            end
+          end
+        end
+      end
+
+      def clip_path(io, shape) #:nodoc:
+        if shape.respond_to?(:clipping) && shape.clipping
+          shape.clipping.each_shapes do |shape, rule|
+            s = shape.dup
+            s.painting.fill = nil
+            s.painting.stroke = nil
+            s.write_as(self, io) {
+              puts_line(io, rule == 'evenodd' ? 'eoclip' : 'clip')
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dyi/formatter/svg_formatter.rb

@@ -0,0 +1,260 @@
+# -*- encoding: UTF-8 -*-
+
+# Copyright (c) 2009-2011 Sound-F Co., Ltd. All rights reserved.
+#
+# Author:: Mamoru Yuo
+#
+# This file is part of DYI.
+#
+# DYI is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# DYI is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with DYI.  If not, see <http://www.gnu.org/licenses/>.
+
+require 'stringio'
+
+module DYI #:nodoc:
+  module Formatter #:nodoc:
+
+    class SvgFormatter < XmlFormatter
+
+      def initialize(canvas, indent=0, level=0, version='1.1')
+        super(canvas, indent, level)
+        raise ArgumentError, "version `#{version}' is unknown version" unless ['1.0', '1.1'].include?(@version = version.to_s)
+        @defs = {}
+      end
+
+      def declaration
+        case @version
+          when '1.0' then %Q{<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.0//EN" "http://www.w3.org/TR/2000/CR-SVG-20001102/DTD/svg-20001102.dtd">}
+          when '1.1' then %Q{<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">}
+        end
+      end
+
+      def puts(io=$>)
+        StringFormat.set_default_formats(:coordinate => 'x,y') {
+          super
+        }
+      end
+
+      def write_canvas(canvas, io)
+        @defs = {}
+        sio = StringIO.new
+        create_node(sio, 'svg',
+            :xmlns => "http://www.w3.org/2000/svg",
+            :version => @version,
+            :width => canvas.real_width,
+            :height => canvas.real_height,
+            :viewBox => canvas.view_box,
+            :preserveAspectRatio => canvas.preserve_aspect_ratio) {
+          @root_info = [sio.pos, @level]
+          canvas.child_elements.each do |element|
+            element.write_as(self, sio)
+          end
+        }
+
+        if @defs.empty?
+          io << sio.string
+        else
+          sio.rewind
+          io << sio.read(@root_info[0])
+
+          _level = @level
+          @level = @root_info[1]
+          create_node(io, 'defs') {
+            @defs.each do |def_id, def_item|
+              def_item.write_as(self, io)
+            end
+          }
+          @level = _level
+
+          io << sio.read
+        end
+      end
+
+      def write_rectangle(shape, io)
+        attrs = {:x=>shape.left, :y=>shape.top, :width=>shape.width, :height=>shape.height}
+        attrs.merge!(common_attributes(shape))
+        attrs[:rx] = shape.attributes[:rx] if shape.attributes[:rx]
+        attrs[:ry] = shape.attributes[:ry] if shape.attributes[:ry]
+        create_leaf_node(io, 'rect', attrs)
+      end
+
+      def write_circle(shape, io)
+        attrs = {:cx=>shape.center.x, :cy=>shape.center.y, :r=>shape.radius}
+        attrs.merge!(common_attributes(shape))
+        create_leaf_node(io, 'circle', attrs)
+      end
+
+      def write_ellipse(shape, io)
+        attrs = {:cx=>shape.center.x, :cy=>shape.center.y, :rx=>shape.radius_x, :ry=>shape.radius_y}
+        attrs.merge!(common_attributes(shape))
+        create_leaf_node(io, 'ellipse', attrs)
+      end
+
+      def write_line(shape, io)
+        attrs = {:x1 => shape.start_point.x, :y1 => shape.start_point.y, :x2 => shape.end_point.x, :y2 => shape.end_point.y}
+        attrs.merge!(common_attributes(shape))
+        create_leaf_node(io, 'line', attrs)
+      end
+
+      def write_polyline(shape, io)
+        attrs = {:points => shape.points.join(' ')}
+        attrs.merge!(common_attributes(shape))
+        create_leaf_node(io, 'polyline', attrs)
+      end
+
+      def write_polygon(shape, io)
+        attrs = {:points => shape.points.join(' ')}
+        attrs.merge!(common_attributes(shape))
+        create_leaf_node(io, 'polygon', attrs)
+      end
+
+      def write_path(shape, io)
+#        attrs = {:d => shape.concise_path_data}
+        attrs = {:d => shape.compatible_path_data.to_concise_syntax}
+        attrs.merge!(common_attributes(shape))
+        create_leaf_node(io, 'path', attrs)
+      end
+
+      def write_text(shape, io)
+        attrs = {:x => shape.point.x, :y => shape.point.y}
+        attrs.merge!(common_attributes(shape))
+        attrs[:"text-decoration"] = shape.attributes[:text_decoration] if shape.attributes[:text_decoration]
+#        attrs[:"alignment-baseline"] = shape.attributes[:alignment_baseline] if shape.attributes[:alignment_baseline]
+        case shape.attributes[:alignment_baseline]
+          when 'top' then attrs[:y] += shape.font_height * 0.85
+          when 'middle' then attrs[:y] += shape.font_height * 0.35
+          when 'bottom' then attrs[:y] -= shape.font_height * 0.15
+        end
+        attrs[:"text-anchor"] = shape.attributes[:text_anchor] if shape.attributes[:text_anchor]
+        attrs[:"writing-mode"] = shape.attributes[:writing_mode] if shape.attributes[:writing_mode]
+        attrs[:textLength] = shape.attributes[:textLength] if shape.attributes[:textLength]
+        attrs[:lengthAdjust] = shape.attributes[:lengthAdjust] if shape.attributes[:lengthAdjust]
+        text = shape.formated_text
+        if text =~ /(\r\n|\n|\r)/
+          create_node(io, 'text', attrs) {
+            create_leaf_node(io, 'tspan', $`.strip, :x => shape.point.x)
+            $'.each_line do |line|
+              create_leaf_node(io, 'tspan', line.strip, :x => shape.point.x, :dy => shape.dy)
+            end
+          }
+        else
+          create_leaf_node(io, 'text', text, attrs)
+        end
+      end
+
+      def write_group(shape, io)
+        create_node(io, 'g', common_attributes(shape)) {
+          shape.child_elements.each do |element|
+            element.write_as(self, io)
+          end
+        } unless shape.child_elements.empty?
+      end
+
+      def write_linear_gradient(shape, io)
+        attr = {
+          :id => @defs.find{|key, value| value==shape}[0],
+          :gradientUnit => 'objectBoundingBox',
+          :x1 => shape.start_point[0],
+          :y1 => shape.start_point[1],
+          :x2 => shape.stop_point[0],
+          :y2 => shape.stop_point[1]}
+        attr[:"spreadMethod"] = shape.spread_method if shape.spread_method
+        create_node(io, 'linearGradient', attr) {
+          shape.child_elements.each do |element|
+            element.write_as(self, io)
+          end
+        }
+      end
+
+      def write_gradient_stop(shape, io)
+        attrs = {:offset=>shape.offset}
+        attrs[:"stop-color"] = shape.color if shape.color
+        attrs[:"stop-opacity"] = shape.opacity if shape.opacity
+        create_leaf_node(io, 'stop', attrs)
+      end
+
+      def write_clipping(clipping, io)
+        attr = {:id => @defs.find{|key, value| value==clipping}[0]}
+        create_node(io, 'clipPath', attr) {
+          clipping.shapes.each_with_index do |shape, i|
+            shape.write_as(self, io)
+          end
+        }
+      end
+
+      private
+
+      def name_to_attribute(name) #:nodoc:
+        name.to_s.gsub(/_/,'-').to_sym
+      end
+
+      def common_attributes(shape) #:nodoc:
+        attributes = {}
+        style = create_style(shape)
+        transform = create_transform(shape)
+        clip_path = create_clip_path(shape)
+        attributes[:style] = style if style
+        attributes[:transform] = transform if transform
+        attributes[:'clip-path'] = clip_path if clip_path
+        attributes
+      end
+
+      def create_style(shape) #:nodoc:
+        styles = {}
+        if shape.respond_to?(:font) && shape.font && !shape.font.empty?
+          styles.merge!(shape.font.attributes)
+        end
+        if shape.respond_to?(:painting) && shape.painting && !shape.painting.empty?
+          attributes = shape.painting.attributes
+          attributes[:stroke_dasharray] = attributes[:stroke_dasharray].join(',') if attributes.key?(:stroke_dasharray)
+          attributes[:fill] = 'none' unless attributes.key?(:fill)
+          styles.merge!(attributes)
+        end
+        styles.empty? ? nil : styles.map {|key, value| "#{attribute_name(key)}:#{attribute_string(value)}"}.join(';')
+      end
+
+      def attribute_string(value) #:nodoc:
+        value.respond_to?(:write_as) ? "url(##{add_defs(value)})" : value.to_s
+      end
+
+      def create_transform(shape) #:nodoc:
+        if shape.respond_to?(:transform) && !shape.transform.empty?
+          shape.transform.map{|item| "#{item[0]}(#{item[1...item.size].join(',')})"}.join(' ')
+        end
+      end
+
+      def create_clip_path(shape) #:nodoc:
+        if shape.respond_to?(:clipping) && shape.clipping
+          "url(##{add_defs(shape.clipping)})"
+        end
+      end
+
+      def add_defs(value) #:nodoc:
+        @defs.each do |def_id, def_item|
+          return def_id if def_item == value
+        end
+        def_id = create_def_id(@defs.size)
+        @defs[def_id] = value
+        def_id
+      end
+
+      def create_def_id(index) #:nodoc:
+        'def%03d' % index
+      end
+
+      def attribute_name(key) #:nodoc:
+        key.to_s.gsub(/_/,'-')
+      end
+    end
+  end
+end