dyi 1.0.3 → 1.1.0

data/CHANGES

@@ -1,5 +1,13 @@
 = DYI Changelog
 
+== Version 1.1.0
+* Major Enhancements
+  * Add DYI::Util module
+  * Can draw a toroid.
+  * Add properties of PieChart.
+  * Support namespace on XML output.
+  * Support Inline-XML mode.
+
 == Version 1.0.3
 * Bug Fixes
   * DataReader is not working properly in Ruby 1.9.

data/lib/dyi.rb

@@ -21,13 +21,14 @@
 
 
 module DYI
-  VERSION = '1.0.3'
+  VERSION = '1.1.0'
   URL = 'http://sourceforge.net/projects/dyi/'
 end
 
 %w(
 
 util
+dyi/util
 dyi/length
 dyi/coordinate
 dyi/color

data/lib/dyi/canvas.rb

@@ -89,15 +89,15 @@ module DYI #:nodoc:
     end
 
     def save(file_name, format=nil, options={})
-      get_formatter(format).save(file_name, options)
+      get_formatter(format, options).save(file_name)
     end
 
-    def puts_in_io(format=nil, io=$>)
-      get_formatter(format).puts(io)
+    def puts_in_io(format=nil, io=$>, options={})
+      get_formatter(format, options).puts(io)
     end
 
-    def string(format=nil)
-      get_formatter(format).string
+    def string(format=nil, options={})
+      get_formatter(format, options).string
     end
 
     def attributes #:nodoc:
@@ -172,10 +172,14 @@ module DYI #:nodoc:
 
     private
 
-    def get_formatter(format=nil) #:nodoc:
+    def get_formatter(format=nil, options={}) #:nodoc:
       case format
-        when :svg, nil then Formatter::SvgFormatter.new(self, 2)
-        when :xaml then Formatter::XamlFormatter.new(self, 2)
+        when :svg, nil
+          options[:indent] = 2 unless options.key?(:indent)
+          Formatter::SvgFormatter.new(self, options)
+        when :xaml
+          options[:indent] = 2 unless options.key?(:indent)
+          Formatter::XamlFormatter.new(self, options)
         when :eps then Formatter::EpsFormatter.new(self)
         when :png then Formatter::PngFormatter.new(self)
         else raise ArgumentError, "`#{format}' is unknown format"

data/lib/dyi/chart/array_reader.rb

@@ -115,6 +115,12 @@ module DYI #:nodoc:
         self
       end
 
+      # @return [Array] a array of a field's name (as Symbol)
+      # @since 1.1.0
+      def members
+        @schema.members.map{|name| name.to_sym}
+      end
+
       private
 
       def primitive_value(value, type=nil)

data/lib/dyi/chart/base.rb

@@ -247,15 +247,15 @@ module DYI #:nodoc:
       end
 
       def save(file_name, format=nil, options={})
-        @canvas.save(file_name, format)
+        @canvas.save(file_name, format, options)
       end
 
-      def puts_in_io(format=nil, io=$>)
-        @canvas.puts_in_io(format, io)
+      def puts_in_io(format=nil, io=$>, options={})
+        @canvas.puts_in_io(format, io, options)
       end
 
-      def string(format=nil)
-        @canvas.string(format)
+      def string(format=nil, options={})
+        @canvas.string(format, options)
       end
 
       private

data/lib/dyi/chart/line_chart.rb

@@ -143,12 +143,17 @@ module DYI #:nodoc:
 
       private
 
+      def initialize(*args)
+        super
+        init_container
+      end
+
       def default_legend_point #:nodoc:
         Coordinate.new(margin_left, 0)
       end
 
       def create_vector_image #:nodoc:
-        init_container
+        super
 
         main_series_data = []
         sub_series_data = []
@@ -235,7 +240,6 @@ module DYI #:nodoc:
               @axis_front_canvas,
               [margin_left - text_margin, y],
               main_y_axis == :left ? settings[:min] : sub_settings[:min],
-              :alignment_baseline=>'middle',
               :text_anchor=>'end',
               :format => (main_y_axis == :left ? axis_format : second_axis_format))
           end
@@ -244,7 +248,6 @@ module DYI #:nodoc:
               @axis_front_canvas,
               [width - margin_right + text_margin, y],
               main_y_axis == :right ? settings[:min] : sub_settings[:min],
-              :alignment_baseline=>'middle',
               :format => (main_y_axis == :right ? axis_format : second_axis_format))
           end
         end

data/lib/dyi/chart/pie_chart.rb

@@ -24,13 +24,13 @@ module DYI #:nodoc:
 
     class PieChart < Base
       include Legend
-      include DYI::Script::EcmaScript::DomLevel2
 
       attr_reader :chart_canvas, :data_label_canvas, :legend_canvas
 
       opt_accessor :center_point, {:type => :point, :default_method => :default_center_point}
       opt_accessor :chart_radius_x, {:type => :length, :default_method => :default_chart_radius_x}
       opt_accessor :chart_radius_y, {:type => :length, :default_method => :default_chart_radius_y}
+      opt_accessor :inner_radius, {:type => :float, :default => 0.0, :range => 0.0 ... 1.0}
       opt_accessor :represent_3d, {:type => :boolean}
       opt_accessor :_3d_settings, {:type => :hash, :default => {}, :keys => [:dy], :item_type => :float}
       opt_accessor :chart_colors, {:type => :array, :item_type => :color}
@@ -182,7 +182,7 @@ module DYI #:nodoc:
           chart_radius_y,
           accumulation * 360.0 / total_value - 90,
           value * 360.0 / total_value,
-          attrs)
+          attrs.merge(:inner_radius => inner_radius))
         @sectors[index] = pie_sector
 
         if moved_elements && (dr = moved_elements[index])
@@ -241,7 +241,7 @@ module DYI #:nodoc:
                                       :duration => animation_duration,
                                       :fill => 'freeze',
                                       :begin_event => Event.mouseout(pie_sector))
-          if show_legend?
+          if @legends
             text.add_painting_animation(:to => {:opacity => 1},
                                         :duration => animation_duration,
                                         :fill => 'freeze',
@@ -274,7 +274,7 @@ module DYI #:nodoc:
                           end
                           maxs
                         end
-          canvas.add_initialize_script(form_legend_labels(legend_canvas))
+          canvas.add_initialize_script(Script::EcmaScript::DomLevel2.form_legend_labels(legend_canvas))
           records.each_with_index do |record, i|
             y = legend_font_size * (1.2 * (i + 1))
             attrs = {}

data/lib/dyi/coordinate.rb

@@ -184,7 +184,7 @@ module DYI #:nodoc:
       end
 
       def polar_coordinates(radius, theta)
-        new(radius * Math.cos(theta * Math::PI / 180), radius * Math.sin(theta * Math::PI / 180))
+        new(radius * DYI::Util.cos(theta), radius * DYI::Util.sin(theta))
       end
 
       def set_default_format(format)

data/lib/dyi/drawing/pen.rb

@@ -66,15 +66,25 @@ module DYI #:nodoc:
         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
+      def draw_polyline(canvas, points, options={})
+        if block_given?
+          polyline = Shape::Polyline.new(points, merge_option(options))
+          yield polyline
+        else
+          polyline = Shape::Polyline.new(points.first, merge_option(options))
+          polyline.line_to(*points[1..-1])
+        end
         polyline.draw_on(canvas)
       end
 
-      def draw_polygon(canvas, point, options={}, &block)
-        polygon = Shape::Polygon.new(point, merge_option(options))
-        yield polygon
+      def draw_polygon(canvas, points, options={})
+        if block_given?
+          polygon = Shape::Polygon.new(points, merge_option(options))
+          yield polygon
+        else
+          polygon = Shape::Polygon.new(points.first, merge_option(options))
+          polygon.line_to(*points[1..-1])
+        end
         polygon.draw_on(canvas)
       end
 
@@ -115,25 +125,62 @@ module DYI #:nodoc:
       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
+        start_angle = (center_angle > 0 ? start_angle : (start_angle + center_angle)) % 360
+        center_angle = center_angle.abs
+        options = merge_option(options)
+        inner_radius = options.delete(:inner_radius).to_f
         center_point = Coordinate.new(center_point)
-        radius_x = Length.new(radius_x)
-        radius_y = Length.new(radius_y)
+        radius_x = Length.new(radius_x).abs
+        radius_y = Length.new(radius_y).abs
         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)
+        if inner_radius >= 1 || 0 > inner_radius
+          raise ArgumentError, "inner_radius option is out of range: #{inner_radius}"
+        end
+        if 360 <= center_angle
+          if inner_radius == 0.0
+            draw_ellipse(canvas, center_point, radius_x, radius_y, options)
           else
-            path.arc_to(arc_end_pt, radius_x, radius_y, 0, large_arc)
+            draw_toroid(canvas, center_point, radius_x, radius_y, inner_radius, options)
           end
-          path.line_to(center_point)
+        else
+          arc_start_pt = Coordinate.new(
+              radius_x * DYI::Util.cos(start_angle),
+              radius_y * DYI::Util.sin(start_angle)) + center_point
+          arc_end_pt = Coordinate.new(
+              radius_x * DYI::Util.cos(start_angle + center_angle),
+              radius_y * DYI::Util.sin(start_angle + center_angle)) + center_point
+
+          draw_sector_internal(canvas, center_point,
+                               radius_x, radius_y, inner_radius,
+                               arc_start_pt, arc_end_pt,
+                               start_angle, center_angle, options)
+        end
+      end
+
+      # @since 1.1.0
+      def draw_toroid(canvas, center_point, radius_x, radius_y, inner_radius, options={})
+        if inner_radius >= 1 || 0 > inner_radius
+          raise ArgumentError, "inner_radius option is out of range: #{inner_radius}"
+        end
+        radius_x, radius_y = Length.new(radius_x).abs, Length.new(radius_y).abs
+        center_point = Coordinate.new(center_point)
+        arc_start_pt = center_point + [radius_x, 0]
+        arc_opposite_pt = center_point - [radius_x, 0]
+        inner_arc_start_pt = center_point + [radius_x * inner_radius, 0]
+        inner_arc_opposite_pt = center_point - [radius_x * inner_radius, 0]
+
+        draw_closed_path(canvas, arc_start_pt, options) {|path|
+          path.arc_to(arc_opposite_pt, radius_x, radius_y, 0, true)
+          path.arc_to(arc_start_pt, radius_x, radius_y, 0, true)
+          path.close_path
+          path.move_to(inner_arc_start_pt)
+          path.arc_to(inner_arc_opposite_pt,
+                      radius_x * inner_radius,
+                      radius_y * inner_radius, 0, true, false)
+          path.arc_to(inner_arc_start_pt,
+                      radius_x * inner_radius,
+                      radius_y * inner_radius, 0, true, false)
         }
       end
 
@@ -146,6 +193,27 @@ module DYI #:nodoc:
       def merge_option(options)
         {:painting=>@painting, :font=>@font}.merge(options)
       end
+
+      # @since 1.1.0
+      def draw_sector_internal(canvas, center_point,
+                               radius_x, radius_y, inner_radius,
+                               arc_start_pt, arc_end_pt,
+                               start_angle, center_angle, merged_options)
+        draw_closed_path(canvas, arc_start_pt, merged_options) {|path|
+          path.arc_to(arc_end_pt, radius_x, radius_y, 0, (180 < center_angle))
+          if inner_radius == 0
+            path.line_to(center_point) if center_angle != 180
+          else
+            inner_arc_start_pt = center_point * (1 - inner_radius) + arc_end_pt * inner_radius
+            inner_arc_end_pt = center_point * (1 - inner_radius) + arc_start_pt * inner_radius
+
+            path.line_to(inner_arc_start_pt)
+            path.arc_to(inner_arc_end_pt,
+                        radius_x * inner_radius,
+                        radius_y * inner_radius, 0, (180 < center_angle), false)
+          end
+        }
+      end
     end
 
     class Pen < PenBase

data/lib/dyi/drawing/pen_3d.rb

@@ -111,6 +111,7 @@ module DYI #:nodoc:
 
     class CylinderBrush < Brush
 
+      # @since 1.1.0
       def initialize(options={})
         self.ry = options.delete(:ry)
         super
@@ -177,6 +178,12 @@ module DYI #:nodoc:
 
     class ColumnBrush < Brush
 
+      def initialize(options={})
+        self.flank_color = options.delete(:flank_color)
+        self.dy = options.delete(:dy)
+        super
+      end
+
       def dy
         @dy || Length.new(16)
       end
@@ -185,85 +192,275 @@ module DYI #:nodoc:
         @dy = Length.new_or_nil(value)
       end
 
-      def draw_sector(canvas, center_point, radius_x, radius_y, start_angle, center_angle, options={})
-        @fill = color
+      # Returns a flank color
+      # @since 1.1.0
+      def flank_color
+        @flank_color || color.merge('black', 0.2)
+      end
+
+      # Set a flank color
+      # @since 1.1.0
+      def flank_color=(color)
+        @flank_color = Color.new_or_nil(color)
+      end
+
+      # Draw a cylinder by specifying the upper surface, which is a circle
+      # @since 1.1.0
+      def draw_circle(canvas, center_point, radius, options={})
+        radius = Length.new(radius).abs
+        center_point = Coordinate.new(center_point)
+        group_options = {}
+        parts_options = merge_option(options)
+        (flank_painting = @painting.dup).fill = flank_color
+        flank_options = parts_options.merge(:painting => flank_painting)
+        [:anchor_href, :anchor_target, :css_class, :id].each do |key|
+          group_options[key] = parts_options.delete(key)
+        end
+        shape = Shape::ShapeGroup.draw_on(canvas, group_options)
+        super(shape, center_point + [0, dy], radius, parts_options)
+        draw_closed_path(shape, center_point - [radius, 0], flank_options) {|path|
+          path.rarc_to([radius * 2, 0], radius, radius)
+          path.rline_to([0, dy])
+          path.rarc_to([- radius * 2, 0], radius, radius, 0, false, false)
+        }
+        draw_closed_path(shape, center_point - [radius, 0], flank_options) {|path|
+          path.rarc_to([radius * 2, 0], radius, radius, 0, false, false)
+          path.rline_to([0, dy])
+          path.rarc_to([- radius * 2, 0], radius, radius)
+        }
+        super(shape, center_point, radius, parts_options)
+        shape
+      end
+
+      # Draw a cylinder by specifying the upper surface, which is a ellipse
+      # @since 1.1.0
+      def draw_ellipse(canvas, center_point, radius_x, radius_y, options={})
+        radius_x, radius_y = Length.new(radius_x).abs, Length.new(radius_y).abs
+        center_point = Coordinate.new(center_point)
+        group_options = {}
+        parts_options = merge_option(options)
+        (flank_painting = @painting.dup).fill = flank_color
+        flank_options = parts_options.merge(:painting => flank_painting)
+        [:anchor_href, :anchor_target, :css_class, :id].each do |key|
+          group_options[key] = parts_options.delete(key)
+        end
+        shape = Shape::ShapeGroup.draw_on(canvas, group_options)
+        super(shape, center_point + [0, dy], radius_x, radius_y, parts_options)
+        draw_closed_path(shape, center_point - [radius_x, 0], flank_options) {|path|
+          path.rarc_to([radius_x * 2, 0], radius_x, radius_y)
+          path.rline_to([0, dy])
+          path.rarc_to([- radius_x * 2, 0], radius_x, radius_y, 0, false, false)
+        }
+        draw_closed_path(shape, center_point - [radius_x, 0], flank_options) {|path|
+          path.rarc_to([radius_x * 2, 0], radius_x, radius_y, 0, false, false)
+          path.rline_to([0, dy])
+          path.rarc_to([- radius_x * 2, 0], radius_x, radius_y)
+        }
+        super(shape, center_point, radius_x, radius_y, parts_options)
+        shape
+      end
 
-        start_angle = (center_angle > 0 ? start_angle : (start_angle + center_angle)) % 360
-        center_angle = center_angle.abs % 360
+      # @since 1.1.0
+      def draw_toroid(canvas, center_point, radius_x, radius_y, inner_radius, options={})
+        if inner_radius >= 1 || 0 > inner_radius
+          raise ArgumentError, "inner_radius option is out of range: #{inner_radius}"
+        end
+        radius_x, radius_y = Length.new(radius_x).abs, Length.new(radius_y).abs
         center_point = Coordinate.new(center_point)
-        radius_x = Length.new(radius_x)
-        radius_y = Length.new(radius_y)
-        large_arc = (center_angle > 180)
+        arc_right_pt = center_point + [radius_x, 0]
+        arc_left_pt = center_point - [radius_x , 0]
+        inner_radius_x = radius_x * inner_radius
+        inner_radius_y = radius_y * inner_radius
+        inner_arc_right_pt = center_point + [inner_radius_x , 0]
+        inner_arc_left_pt = center_point - [inner_radius_x, 0]
+        group_options = {}
+        parts_options = merge_option(options)
+        (flank_painting = @painting.dup).fill = flank_color
+        flank_options = parts_options.merge(:painting => flank_painting)
+        [:anchor_href, :anchor_target, :css_class, :id].each do |key|
+          group_options[key] = parts_options.delete(key)
+        end
+        shape = Shape::ShapeGroup.draw_on(canvas, group_options)
+
+        super(shape, center_point + [0, dy], radius_x, radius_y, inner_radius, parts_options)
+        draw_sector_back_flank(shape, center_point,
+                               radius_x, radius_y,
+                               arc_left_pt, arc_right_pt,
+                               180, 180, flank_options)
+        draw_sector_back_flank(shape, center_point,
+                               inner_radius_x, inner_radius_y,
+                               inner_arc_left_pt, inner_arc_right_pt,
+                               180, 180, flank_options)
+        draw_sector_front_flank(shape, center_point,
+                                inner_radius_x, inner_radius_y,
+                                inner_arc_right_pt, inner_arc_left_pt,
+                                0, 180, flank_options)
+        draw_sector_front_flank(shape, center_point,
+                                radius_x, radius_y,
+                                arc_right_pt, arc_left_pt,
+                                0, 180, flank_options)
+        super(shape, center_point, radius_x, radius_y, inner_radius, parts_options)
+      end
 
-        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
+      private
 
-        org_opacity = opacity
-        if org_color = color
-          self.color = color.merge('black', 0.2)
+      # @since 1.1.0
+      def draw_sector_internal(canvas, center_point,
+                               radius_x, radius_y, inner_radius,
+                               arc_start_pt, arc_end_pt,
+                               start_angle, center_angle, merged_options)
+        if inner_radius == 0
+          inner_arc_start_pt = inner_arc_end_pt = center_point
         else
-          self.color = 'black'
-          self.opacity = 0.2
+          inner_arc_start_pt = center_point * (1 - inner_radius) + arc_end_pt * inner_radius
+          inner_arc_end_pt = center_point * (1 - inner_radius) + arc_start_pt * inner_radius
+          inner_radius_x = radius_x * inner_radius
+          inner_radius_y = radius_y * inner_radius
+        end
+        group_options = {}
+        parts_options = merged_options.dup
+        (flank_painting = @painting.dup).fill = flank_color
+        flank_options = parts_options.merge(:painting => flank_painting)
+        [:anchor_href, :anchor_target, :css_class, :id].each do |key|
+          group_options[key] = parts_options.delete(key)
         end
+        shape = Shape::ShapeGroup.draw_on(canvas, group_options)
 
-        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)
+        super(shape, center_point + [0, dy],
+              radius_x, radius_y, inner_radius,
+              arc_start_pt + [0, dy], arc_end_pt + [0, dy],
+              start_angle, center_angle, parts_options)
+
+        draw_sector_back_flank(shape, center_point,
+                               radius_x, radius_y,
+                               arc_start_pt, arc_end_pt,
+                               start_angle, center_angle, flank_options)
+
+        if center_angle == 180 && inner_radius == 0
+          draw_polygon(shape, arc_start_pt, flank_options) {|polygon|
+            polygon.line_to(arc_start_pt + [0, dy], arc_end_pt + [0, dy], arc_end_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)
-          }
+          pt_ys = [[arc_start_pt.y, proc {
+                        draw_polygon(shape, inner_arc_end_pt, flank_options) {|polygon|
+                          polygon.line_to(inner_arc_end_pt + [0, dy], arc_start_pt + [0, dy], arc_start_pt)
+                        }
+                      }],
+                   [arc_end_pt.y, proc {
+                        draw_polygon(shape, inner_arc_start_pt, flank_options) {|polygon|
+                          polygon.line_to(inner_arc_start_pt + [0, dy], arc_end_pt + [0, dy], arc_end_pt)
+                        }
+                      }],
+                   [center_point.y, proc {
+                        if inner_radius != 0
+                          draw_sector_back_flank(shape, center_point,
+                                                 inner_radius_x, inner_radius_y,
+                                                 inner_arc_end_pt, inner_arc_start_pt,
+                                                 start_angle, center_angle, flank_options)
+                          draw_sector_front_flank(shape, center_point,
+                                                  inner_radius_x, inner_radius_y,
+                                                  inner_arc_end_pt, inner_arc_start_pt,
+                                                  start_angle, center_angle, flank_options)
+                        end
+                      }]]
+
+          pt_ys.sort{|a,b| a[0] <=> b[0]}.each do |pt_y|
+            pt_y[1].call
+          end
         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)
+
+        draw_sector_front_flank(shape, center_point,
+                                radius_x, radius_y,
+                                arc_start_pt, arc_end_pt,
+                                start_angle, center_angle, flank_options)
+
+        super(shape, center_point,
+              radius_x, radius_y, inner_radius,
+              arc_start_pt, arc_end_pt,
+              start_angle, center_angle, parts_options)
+        shape
+      end
+
+      # @since 1.1.0
+      def draw_sector_back_flank(canvas, center_point,
+                                 radius_x, radius_y,
+                                 arc_start_pt, arc_end_pt,
+                                 start_angle, center_angle, options)
+        if start_angle < 180
+          if 360 < start_angle + center_angle
+            draw_closed_path(canvas, center_point - [radius_x, 0], options) {|path|
+              path.rarc_to([radius_x * 2, 0], radius_x, radius_y)
+              path.rline_to([0, dy])
+              path.rarc_to([- radius_x * 2, 0], radius_x, radius_y, 0, false, false)
+            }
+          elsif 180 < start_angle + center_angle
+            draw_closed_path(canvas, center_point - [radius_x, 0], options) {|path|
+              path.arc_to(arc_end_pt, radius_x, radius_y)
+              path.rline_to([0, dy])
+              path.arc_to(center_point + [-radius_x, dy], radius_x, radius_y, 0, false, false)
+            }
+          end
+        elsif 360 < start_angle + center_angle
+          draw_closed_path(canvas, arc_start_pt, options) {|path|
+            path.arc_to(center_point + [radius_x, 0], radius_x, radius_y)
+            path.rline_to([0, dy])
+            path.arc_to(arc_start_pt + [0, dy], radius_x, radius_y, 0, false, false)
+            if 540 < start_angle + center_angle
+              path.close_path
+              path.move_to(center_point - [radius_x, 0])
+              path.arc_to(arc_end_pt, radius_x, radius_y)
+              path.rline_to([0, dy])
+              path.arc_to(center_point + [-radius_x, dy], 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
+        else
+          draw_closed_path(canvas, arc_start_pt, options) {|path|
+            path.arc_to(arc_end_pt, radius_x, radius_y)
+            path.rline_to([0, dy])
+            path.arc_to(arc_start_pt + [0, dy], radius_x, radius_y, 0, false, false)
           }
         end
-        self.color = org_color
-        self.opacity = org_opacity
+      end
 
-        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)
-        }
+      # @since 1.1.0
+      def draw_sector_front_flank(canvas, center_point,
+                                  radius_x, radius_y,
+                                  arc_start_pt, arc_end_pt,
+                                  start_angle, center_angle, options)
+        if start_angle < 180
+          if 180 < start_angle + center_angle
+            draw_closed_path(canvas, arc_start_pt, options) {|path|
+              path.arc_to(center_point - [radius_x, 0], radius_x, radius_y)
+              path.rline_to([0, dy])
+              path.arc_to(arc_start_pt + [0, dy], radius_x, radius_y, 0, false, false)
+              if 360 < start_angle + center_angle
+                path.close_path
+                path.move_to(center_point + [radius_x, 0])
+                path.arc_to(arc_end_pt, radius_x, radius_y)
+                path.rline_to([0, dy])
+                path.arc_to(center_point + [radius_x, dy], radius_x, radius_y, 0, false, false)
+              end
+            }
+          else
+            draw_closed_path(canvas, arc_start_pt, options) {|path|
+              path.arc_to(arc_end_pt, radius_x, radius_y)
+              path.rline_to([0, dy])
+              path.arc_to(arc_start_pt + [0, dy], radius_x, radius_y, 0, false, false)
+            }
+          end
+        elsif 540 < start_angle + center_angle
+          draw_closed_path(canvas, center_point + [radius_x, 0], options) {|path|
+            path.arc_to(center_point - [radius_x, 0], radius_x, radius_y)
+            path.rline_to([0, dy])
+            path.arc_to(center_point + [radius_x, dy], radius_x, radius_y, 0, false, false)
+          }
+        elsif 360 < start_angle + center_angle
+          draw_closed_path(canvas, center_point + [radius_x, 0], options) {|path|
+            path.arc_to(arc_end_pt, radius_x, radius_y)
+            path.rline_to([0, dy])
+            path.arc_to(center_point + [radius_x, dy], radius_x, radius_y, 0, false, false)
+          }
+        end
       end
     end
   end