dyi 0.0.0

data/lib/dyi/drawing/filter.rb

@@ -0,0 +1,74 @@
+# -*- 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/>.
+
+module DYI #:nodoc:
+  module Drawing #:nodoc:
+    module Filter #:nodoc:
+
+      class DropShadow
+        include DYI::SvgElement
+        attr_reader :id
+
+        def initialize(canvas, blur_std, dx, dy)
+          @canvas = canvas
+          @blur_std = blur_std.to_i
+          @dx = Length.new(dx)
+          @dy = Length.new(dy)
+          @id = @canvas.add_define(self)
+        end
+
+        def child_elements
+          []
+        end
+
+        def draw_children?
+          true
+        end
+
+        private
+
+        def attributes #:nodoc:
+          {
+            :id => @id,
+            :filterUnits => 'userSpaceOnUse',
+            :x => 0,
+            :y => 0,
+            :width => @canvas.width,
+            :height => @canvas.height,
+          }
+        end
+
+        def svg_tag #:nodoc:
+           'filter'
+        end
+
+        def child_elements_to_svg(xml) #:nodoc:
+          xml.feGaussianBlur(:in => 'SourceAlpha', :stdDeviation => @blur_std, :result => 'blur')
+          xml.feOffset(:in => 'blur', :dx => @dx, :dy => @dy,  :result => 'offsetBlur')
+          xml.feMerge {
+            xml.feMergeNode(:in => 'offsetBlur')
+            xml.feMergeNode(:in => 'SourceGraphic')
+          }
+        end
+      end
+    end
+  end
+end

data/lib/dyi/drawing/pen.rb

@@ -0,0 +1,231 @@
+# -*- 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/>.
+
+module DYI #:nodoc:
+  module Drawing #:nodoc:
+
+    class PenBase
+      extend AttributeCreator
+      DROP_SHADOW_OPTIONS = [:blur_std, :dx, :dy]
+      attr_font :font
+      attr_reader :drop_shadow
+
+      def initialize(options={})
+        @attributes = {}
+        @painting = Painting.new
+        options.each do |key, value|
+          if key.to_sym == :font
+            self.font = value
+          elsif Painting::IMPLEMENT_ATTRIBUTES.include?(key)
+            @painting.__send__("#{key}=", value)
+          else
+            @attributes[key] = value
+          end
+        end
+      end
+
+      Painting::IMPLEMENT_ATTRIBUTES.each do |painting_attr|
+        define_method(painting_attr) {| | @painting.__send__(painting_attr)}
+        define_method("#{painting_attr}=".to_sym) {|value|
+          @painting = @painting.dup
+          @painting.__send__("#{painting_attr}=".to_sym, value)
+        }
+      end
+
+      def drop_shadow=(options)
+        DROP_SHADOW_OPTIONS.each do |key|
+          @drop_shadow[key] = options[key.to_sym] if options[key.to_sym]
+        end
+      end
+
+      def draw_line(canvas, start_point, end_point, options={})
+        Shape::Line.create_on_start_end(start_point, end_point, merge_option(options)).draw_on(canvas)
+      end
+
+      alias draw_line_on_start_end draw_line
+
+      def draw_line_on_direction(canvas, start_point, direction_x, direction_y, options={})
+        Shape::Line.create_on_direction(start_point, direction_x, direction_y, merge_option(options)).draw_on(canvas)
+      end
+
+      def draw_polyline(canvas, point, options={}, &block)
+        polyline = Shape::Polyline.new(point, merge_option(options))
+        yield polyline
+        polyline.draw_on(canvas)
+      end
+
+      def draw_polygon(canvas, point, options={}, &block)
+        polygon = Shape::Polygon.new(point, merge_option(options))
+        yield polygon
+        polygon.draw_on(canvas)
+      end
+
+      def draw_rectangle(canvas, left_top_point, width, height, options={})
+        Shape::Rectangle.create_on_width_height(left_top_point, width, height, merge_option(options)).draw_on(canvas)
+      end
+
+      alias draw_rectangle_on_width_height draw_rectangle
+
+      def draw_rectangle_on_corner(canvas, top, right, bottom, left, options={})
+        Shape::Rectangle.create_on_corner(top, right, bottom, left, merge_option(options)).draw_on(canvas)
+      end
+
+      def draw_path(canvas, point, options={}, &block)
+        Shape::Path.draw(point, merge_option(options), &block).draw_on(canvas)
+      end
+
+      def draw_closed_path(canvas, point, options={}, &block)
+        Shape::Path.draw_and_close(point, merge_option(options), &block).draw_on(canvas)
+      end
+
+      def draw_circle(canvas, center_point, radius, options={})
+        Shape::Circle.create_on_center_radius(center_point, radius, merge_option(options)).draw_on(canvas)
+      end
+
+      def draw_ellipse(canvas, center_point, radius_x, radius_y, options={})
+        Shape::Ellipse.create_on_center_radius(center_point, radius_x, radius_y, merge_option(options)).draw_on(canvas)
+      end
+
+      def draw_sector(canvas, center_point, radius_x, radius_y, start_angle, center_angle, options={})
+        raise ArgumentError, "center_angle is out of range: #{center_angle}" if center_angle.abs > 360
+        center_point = Coordinate.new(center_point)
+        radius_x = Length.new(radius_x)
+        radius_y = Length.new(radius_y)
+        large_arc = (center_angle.abs > 180)
+
+        arc_start_pt = Coordinate.new(radius_x * Math.cos(Math::PI * start_angle / 180), radius_y * Math.sin(Math::PI * start_angle / 180)) + center_point
+        arc_end_pt = Coordinate.new(radius_x * Math.cos(Math::PI * (start_angle + center_angle) / 180), radius_y * Math.sin(Math::PI * (start_angle + center_angle) / 180)) + center_point
+
+        draw_path(canvas, center_point, merge_option(options)) {|path|
+          path.line_to(arc_start_pt)
+          if center_angle.abs > 270
+            transit_pt = center_point * 2 - arc_start_pt
+            path.arc_to(transit_pt, radius_x, radius_y, 0, true)
+            path.arc_to(arc_end_pt, radius_x, radius_y, 0, false)
+          else
+            path.arc_to(arc_end_pt, radius_x, radius_y, 0, large_arc)
+          end
+          path.line_to(center_point)
+        }
+      end
+
+      def draw_text(canvas, point, text, options={})
+        Shape::Text.new(point, text, merge_option(options)).draw_on(canvas)
+      end
+
+      private
+
+      def merge_option(options)
+        {:painting=>@painting, :font=>@font}.merge(options)
+      end
+    end
+
+    class Pen < PenBase
+      #:stopdoc:
+      ALIAS_ATTRIBUTES =
+        Painting::IMPLEMENT_ATTRIBUTES.inject({}) do |hash, key|
+          hash[$'.empty? ? :color : $'.to_sym] = key if key.to_s =~ /^(stroke_|stroke$)/
+          hash
+        end
+      #:startdoc:
+
+      def initialize(options={})
+        options = options.dup
+        ALIAS_ATTRIBUTES.each do |key, value|
+          options[value] = options.delete(key) if options.key?(key) && !options.key?(value)
+        end
+        options[:stroke] = 'black' unless options.key?(:stroke)
+        super
+      end
+
+      ALIAS_ATTRIBUTES.each do |key, value|
+        alias_method key, value
+        alias_method "#{key}=", "#{value}="
+      end
+
+      def draw_text(canvas, point, text, options={})
+        painting = @painting
+        text_painting = Painting.new(painting)
+        text_painting.fill = painting.stroke
+        text_painting.fill_opacity = painting.stroke_opacity
+        text_painting.stroke = nil
+        text_painting.stroke_width = nil
+        @painting = text_painting
+        shape = super
+        @painting = painting
+        shape
+      end
+
+      class << self
+        def method_missing(method_name, *args, &block) #:nodoc:
+          if method_name.to_s =~ /^([a-z]+)_pen$/
+            if options = args.first
+              self.new(options.merge(:stroke => $1))
+            else
+              self.new(:stroke => $1)
+            end
+          else
+            super
+          end
+        end
+      end
+    end
+
+    class Brush < PenBase
+      #:stopdoc:
+      ALIAS_ATTRIBUTES =
+        Painting::IMPLEMENT_ATTRIBUTES.inject({}) do |hash, key|
+          hash[$'.empty? ? :color : $'.to_sym] = key if key.to_s =~ /^(fill_|fill$)/
+          hash
+        end
+      #:startdoc:
+
+      def initialize(options={})
+        options = options.dup
+        ALIAS_ATTRIBUTES.each do |key, value|
+          options[value] = options.delete(key) if options.key?(key) && !options.key?(value)
+        end
+        options[:stroke_width] = 0 unless options.key?(:stroke_width)
+        options[:fill] = 'black' unless options.key?(:fill)
+        super
+      end
+
+      ALIAS_ATTRIBUTES.each do |key, value|
+        alias_method key, value
+        alias_method "#{key}=", "#{value}="
+      end
+
+      class << self
+        def method_missing(method_name, *args, &block) #:nodoc:
+          if method_name.to_s =~ /([a-z]+)_brush/
+            if options = args.first
+              self.new(options.merge(:fill => $1))
+            else
+              self.new(:fill => $1)
+            end
+          else
+            super
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dyi/drawing/pen_3d.rb

@@ -0,0 +1,270 @@
+# -*- 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/>.
+
+module DYI #:nodoc:
+  module Drawing #:nodoc:
+
+    class CubicPen < Pen
+      POSITION_TYPE_VALUES = [:baseline, :center, :backline]
+      attr_reader :position_type, :background_color, :background_opacity, :dx, :dy
+
+      def initialize(options={})
+        self.position_type = options.delete(:position_type)
+        self.background_color = options.delete(:background_color)
+        self.background_opacity = options.delete(:background_opacity)
+        self.dx = options.delete(:dx)
+        self.dy = options.delete(:dy)
+        super
+      end
+
+      def position_type=(value)
+        if value.to_s.size != 0
+          raise ArgumentError, "\"#{value}\" is invalid position-type" unless POSITION_TYPE_VALUES.include?(value)
+          @position_type = value
+        else
+          @position_type = nil
+        end
+      end
+
+      def background_color=(color)
+        @background_color = Color.new_or_nil(color)
+      end
+
+      def background_opacity=(opacity)
+        @background_opacity = opacity ? opacity.to_f : nil
+      end
+
+      def dx
+        @dx || Length.new(24)
+      end
+
+      def dx=(value)
+        @dx = Length.new_or_nil(value)
+      end
+
+      def dy
+        @dy || Length.new(-8)
+      end
+
+      def dy=(value)
+        @dy = Length.new_or_nil(value)
+      end
+
+      def brush
+        @brush ||= Brush.new(:color => background_color || color, :opacity => background_opacity || nil)
+      end
+
+      def draw_line(canvas, start_point, end_point, options={})
+        group = Shape::ShapeGroup.new
+        draw_background_shape(group, start_point, end_point, options)
+        super(group, start_point, end_point, options)
+        adjust_z_coordinate(group)
+        group.draw_on(canvas)
+      end
+
+      def draw_polyline(canvas, point, options={}, &block)
+        group = Shape::ShapeGroup.new(options)
+        polyline = super(group, point, {}, &block)
+        (1...polyline.points.size).each do |i|
+          draw_background_shape(group, polyline.points[i-1], polyline.points[i], {})
+        end
+        polyline = super(group, point, {}, &block)
+        adjust_z_coordinate(group)
+        group.draw_on(canvas)
+      end
+
+      private
+
+      def adjust_z_coordinate(shape) #:nodoc:
+        case position_type
+          when :center then shape.translate(-dx / 2, -dy / 2)
+          when :backline then shape.translate(-dx, -dy)
+        end
+      end
+
+      def draw_background_shape(canvas, start_point, end_point, options={}) #:nodoc:
+        brush.draw_polygon(canvas, start_point, options) {|polygon|
+          polygon.line_to(end_point)
+          polygon.line_to(Coordinate.new(end_point) + Coordinate.new(dx, dy))
+          polygon.line_to(Coordinate.new(start_point) + Coordinate.new(dx, dy))
+        }
+      end
+    end
+
+    class CylinderBrush < Brush
+
+      def initialize(options={})
+        self.ry = options.delete(:ry)
+        super
+      end
+
+      def ry
+        @ry || Length.new(8)
+      end
+
+      def ry=(value)
+        @ry = Length.new_or_nil(value)
+      end
+
+      def fill
+        @painting.fill
+      end
+
+      def fill=(value)
+        if @painting.fill != Color.new_or_nil(value)
+          @painting.fill = Color.new_or_nil(value)
+        end
+        value
+      end
+
+      alias color fill
+      alias color= fill=
+
+      def draw_rectangle(canvas, left_top_point, width, height, options={})
+        radius_x = width.quo(2)
+        radius_y = ry
+
+        shape = Shape::ShapeGroup.draw_on(canvas)
+        top_painting = @painting.dup
+        top_painting.fill = top_color
+        Shape::Ellipse.create_on_center_radius(Coordinate.new(left_top_point) + [width.quo(2), 0], radius_x, radius_y, merge_option(:painting => top_painting)).draw_on(shape)
+        body_painting = @painting.dup
+        body_painting.fill = body_gradient(canvas)
+        Shape::Path.draw(left_top_point, merge_option(:painting => body_painting)) {|path|
+          path.rarc_to([width, 0], radius_x, radius_y, 0, false, false)
+          path.rline_to([0, height])
+          path.rarc_to([-width, 0], radius_x, radius_y, 0, false, true)
+          path.rline_to([0, -height])
+        }.draw_on(shape)
+        shape
+      end
+
+      private
+
+      def body_gradient(canvas) #:nodoc:
+        gradient = ColorEffect::LinearGradient.new([0,0],[1,0])
+        gradient.add_color(0, color.merge(Color.white, 0.4))
+        gradient.add_color(0.3, color.merge(Color.white, 0.65))
+        gradient.add_color(0.4, color.merge(Color.white, 0.7))
+        gradient.add_color(0.5, color.merge(Color.white, 0.65))
+        gradient.add_color(0.7, color.merge(Color.white, 0.4))
+        gradient.add_color(1, color)
+        gradient
+      end
+
+      def top_color #:nodoc:
+        color.merge(Color.white, 0.3)
+      end
+    end
+
+    class ColumnBrush < Brush
+
+      def dy
+        @dy || Length.new(16)
+      end
+
+      def dy=(value)
+        @dy = Length.new_or_nil(value)
+      end
+
+      def draw_sector(canvas, center_point, radius_x, radius_y, start_angle, center_angle, options={})
+        @fill = color
+
+        start_angle = (center_angle > 0 ? start_angle : (start_angle + center_angle)) % 360
+        center_angle = center_angle.abs % 360
+        center_point = Coordinate.new(center_point)
+        radius_x = Length.new(radius_x)
+        radius_y = Length.new(radius_y)
+        large_arc = (center_angle > 180)
+
+        arc_start_pt = Coordinate.new(radius_x * Math.cos(Math::PI * start_angle / 180), radius_y * Math.sin(Math::PI * start_angle / 180)) + center_point
+        arc_end_pt = Coordinate.new(radius_x * Math.cos(Math::PI * (start_angle + center_angle) / 180), radius_y * Math.sin(Math::PI * (start_angle + center_angle) / 180)) + center_point
+
+        org_opacity = opacity
+        if org_color = color
+          self.color = color.merge('black', 0.2)
+        else
+          self.color = 'black'
+          self.opacity = 0.2
+        end
+
+        if (90..270).include?(start_angle) && center_angle < 180
+          draw_polygon(canvas, center_point, options) {|polygon|
+            polygon.line_to(center_point + [0, dy])
+            polygon.line_to(arc_end_pt + [0, dy])
+            polygon.line_to(arc_end_pt)
+          }
+          draw_polygon(canvas, center_point, options) {|polygon|
+            polygon.line_to(center_point + [0, dy])
+            polygon.line_to(arc_start_pt + [0, dy])
+            polygon.line_to(arc_start_pt)
+          }
+        else
+          draw_polygon(canvas, center_point, options) {|polygon|
+            polygon.line_to(center_point + [0, dy])
+            polygon.line_to(arc_start_pt + [0, dy])
+            polygon.line_to(arc_start_pt)
+          }
+          draw_polygon(canvas, center_point, options) {|polygon|
+            polygon.line_to(center_point + [0, dy])
+            polygon.line_to(arc_end_pt + [0, dy])
+            polygon.line_to(arc_end_pt)
+          }
+        end
+        if (0..180).include?(start_angle)
+          draw_path(canvas, arc_start_pt, options) {|path|
+            path.line_to(arc_start_pt + [0, dy])
+            if arc_end_pt.y >= center_point.y
+              path.arc_to(arc_end_pt + [0, dy], radius_x, radius_y, 0, false)
+              path.line_to(arc_end_pt)
+              path.arc_to(arc_start_pt, radius_x, radius_y, 0, false, false)
+            else
+              path.arc_to(center_point + [-(radius_x.abs), dy], radius_x, radius_y, 0, false)
+              path.line_to(center_point + [-(radius_x.abs), 0])
+              path.arc_to(arc_start_pt, radius_x, radius_y, 0, false, false)
+            end
+          }
+        elsif (270..360).include?(start_angle) && start_angle + center_angle > 360
+          draw_path(canvas, center_point + [radius_x.abs, 0], options) {|path|
+            path.line_to(center_point + [radius_x.abs, dy])
+            if arc_end_pt.y >= center_point.y
+              path.arc_to(arc_end_pt + [0, dy], radius_x, radius_y, 0, false)
+              path.line_to(arc_end_pt)
+              path.arc_to(center_point + [radius_x.abs, 0], radius_x, radius_y, 0, false, false)
+            else
+              path.arc_to(center_point + [-(radius_x.abs), dy], radius_x, radius_y, 0, false)
+              path.line_to(center_point + [-(radius_x.abs), 0])
+              path.arc_to(center_point + [radius_x.abs, 0], radius_x, radius_y, 0, false, false)
+            end
+          }
+        end
+        self.color = org_color
+        self.opacity = org_opacity
+
+        draw_path(canvas, center_point, options) {|path|
+          path.line_to(arc_start_pt)
+          path.arc_to(arc_end_pt, radius_x, radius_y, 0, large_arc)
+          path.line_to(center_point)
+        }
+      end
+    end
+  end
+end