dyi 0.0.2 → 1.0.0

data/lib/dyi/chart/csv_reader.rb

@@ -79,10 +79,6 @@ module DYI #:nodoc:
         end
       end
 
-      def primitive_title_value(value, type=nil)
-        value
-      end
-
       class << self
         def read(path, options={})
           new.read(path, options)

data/lib/dyi/chart/legend.rb

@@ -0,0 +1,82 @@
+# -*- 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 Chart #:nodoc:
+
+    module Legend
+
+      private
+
+      def draw_legend(names, shapes=nil, records=nil, colors=nil) #:nodoc:
+        legend_canvas.translate(legend_point.x, legend_point.y)
+        if show_legend?
+          pen = Drawing::Pen.black_pen(:font => legend_font)
+          brush = Drawing::Brush.new
+          names.each_with_index do |name, index|
+            y = legend_font_size * (1.2 * (index + 1))
+            group = Shape::ShapeGroup.draw_on(legend_canvas)
+            case shapes && shapes[index]
+            when Shape::Base
+              shapes[index].draw_on(group)
+            when NilClass
+              brush.color = colors && colors[index] || chart_color(index)
+              brush.draw_rectangle(
+                group,
+                Coordinate.new(legend_font_size * 0.2, y - legend_font_size * 0.8),
+                legend_font_size * 0.8,
+                legend_font_size * 0.8)
+            end
+            pen.draw_text(
+              group,
+              Coordinate.new(legend_font_size * 0.2 + legend_font_size, y),
+              name)
+          end
+        end
+      end
+
+      def legend_font_size #:nodoc:
+        legend_font ? legend_font.draw_size : Font::DEFAULT_SIZE
+      end
+
+      def default_legend_point #:nodoc:
+        Coordinate.new(0,0)
+      end
+
+      def default_legend_format #:nodoc:
+        "{name}"
+      end
+
+      class << self
+
+        private
+
+        def included(klass) #:nodoc:
+          klass.__send__(:opt_accessor, :show_legend, :type => :boolean, :default => true)
+          klass.__send__(:opt_accessor, :legend_font, :type => :font)
+          klass.__send__(:opt_accessor, :legend_format, :type => :string, :default_method => :default_legend_format)
+          klass.__send__(:opt_accessor, :legend_point, :type => :point, :default_method => :default_legend_point)
+          klass.__send__(:opt_accessor, :legend_css_class, :type => :string)
+        end
+      end
+    end
+  end
+end

data/lib/dyi/chart/line_chart.rb

@@ -50,7 +50,7 @@ module DYI #:nodoc:
       opt_accessor :max_x_label_count, {:type => :integer, :default_proc => proc{|c| c.chart_width.div(Length.new(96))}}
       opt_accessor :show_x_labels, {:type => :boolean, :default => true}
       opt_accessor :legend_texts, {:type => :array, :item_type => :string}
-      opt_accessor :data_columns, {:type => :array, :item_type => :integer}
+#      opt_accessor :data_columns, {:type => :array, :item_type => :integer}
       opt_accessor :use_effect, {:type => :boolean, :default => true}
       opt_accessor :bar_seriese_interval, {:type => :float, :default => 0.3}
       opt_accessor :color_columns, {:type => :array, :item_type => :integer}
@@ -130,7 +130,7 @@ module DYI #:nodoc:
 
       def bar_chart_brush(color, bar_width=nil)
         if represent_3d?
-          bar_width ||= chart_width * bar_width_ratio / data.column_values(data_columns[0]).size
+          bar_width ||= chart_width * bar_width_ratio / data.records_size
           Drawing::CylinderBrush.new(:color => color, :ry => bar_width * (back_translate_value[:dy] * bar_width_ratio).quo(back_translate_value[:dx] * 2))
         else
           Drawing::Brush.new(:color => color)
@@ -153,9 +153,9 @@ module DYI #:nodoc:
         main_series_data = []
         sub_series_data = []
         @bar_series = []
-        data_columns.size.times do |i|
-          main_series_data.push(*data.column_values(data_columns[i])) unless use_y_second_axis?(i)
-          sub_series_data.push(*data.column_values(data_columns[i])) if use_y_second_axis?(i)
+        data.values_size.times do |i|
+          main_series_data.push(*data.series(i)) unless use_y_second_axis?(i)
+          sub_series_data.push(*data.series(i)) if use_y_second_axis?(i)
           @bar_series.push(i) if chart_type(i) == :bar
         end
         settings =
@@ -172,15 +172,15 @@ module DYI #:nodoc:
             second_axis_settings[:min],
             second_axis_settings[:max]) if use_y_second_axis?
 
-        data_columns.size.times do |i|
-          draw_chart(data_columns[i], chart_type(i), chart_color(i), use_y_second_axis?(i) ? sub_settings : settings) if chart_type(i) == :stackedbar
+        data.values_size.times do |i|
+          draw_chart(i, chart_type(i), chart_color(i), use_y_second_axis?(i) ? sub_settings : settings) if chart_type(i) == :stackedbar
         end
-        (data_columns.size-1).downto(0) do |i|
-          draw_chart(data_columns[i], chart_type(i), chart_color(i), use_y_second_axis?(i) ? sub_settings : settings) if chart_type(i) != :stackedbar
+        (data.values_size - 1).downto(0) do |i|
+          draw_chart(i, chart_type(i), chart_color(i), use_y_second_axis?(i) ? sub_settings : settings) if chart_type(i) != :stackedbar
         end
 
         draw_axis(settings, sub_settings)
-        texts = legend_texts || data_columns.map{|i| data.column_title(i)}
+        texts = legend_texts # || data_columns.map{|i| data.column_title(i)}
         draw_legend(texts, legend_shapes)
       end
 
@@ -314,28 +314,28 @@ module DYI #:nodoc:
       end
 
       def needs_x_scale?(i)
-        return true if data.row_count < max_x_label_count
-        i % ((data.row_count - 1) / [max_x_label_count - 1, 1].max) == 0
+        return true if data.records_size < max_x_label_count
+        i % ((data.records_size - 1) / [max_x_label_count - 1, 1].max) == 0
       end
 
       def draw_x_axis(main_pen, sub_pen, text_pen, text_margin) #:nodoc:
         main_pen.draw_line(represent_3d? ? @axis_back_canvas : @axis_front_canvas, [margin_left, height - margin_bottom], [width - margin_right, height - margin_bottom])
 
-        data.row_count.times do |i|
+        data.records_size.times do |i|
           next unless needs_x_scale?(i)
-          text_x = order_position_on_chart(margin_left, chart_width, data.row_count, i, x_axis_type)
-          scale_x = x_axis_type == :range ? order_position_on_chart(margin_left, chart_width, data.row_count + 1, i) : text_x
+          text_x = order_position_on_chart(margin_left, chart_width, data.records_size, i, x_axis_type)
+          scale_x = x_axis_type == :range ? order_position_on_chart(margin_left, chart_width, data.records_size + 1, i) : text_x
           text_pen.draw_text(
             @axis_front_canvas,
             [text_x, height - margin_bottom + text_margin],
-            format_x_label(data.row_title(i)),
+            format_x_label(data.name_values[i]),
             :text_anchor => 'middle', :alignment_baseline => 'top') if show_x_labels?
 
           sub_pen.draw_line_on_direction(
             @axis_front_canvas,
             [scale_x, height - margin_bottom],
             0,
-            -(axis_font ? axis_font.draw_size : Font::DEFAULT_SIZE) * 0.5) if i > 0 && i < data.row_count - (x_axis_type == :range ? 0 : 1)
+            -(axis_font ? axis_font.draw_size : Font::DEFAULT_SIZE) * 0.5) if i > 0 && i < data.records_size - (x_axis_type == :range ? 0 : 1)
         end
       end
 
@@ -349,7 +349,7 @@ module DYI #:nodoc:
       end
 
       def draw_line(id, color, settings) #:nodoc:
-        values = data.column_values(id)
+        values = data.series(id)
         return if values.compact.size == 0
         first_index = values.each_with_index {|value, i| break i if value}
         pen_options = {:color => color, :width => line_width}
@@ -369,7 +369,7 @@ module DYI #:nodoc:
       end
 
       def draw_area(id, color, settings) #:nodoc:
-        values = data.column_values(id)
+        values = data.series(id)
         return if values.compact.size == 0
         first_index = values.each_with_index {|value, i| break i if value}
         brush = area_chart_brush(color)
@@ -390,7 +390,7 @@ module DYI #:nodoc:
 
       def draw_bar(id, color, settings) #:nodoc:
         bar_group = Shape::ShapeGroup.new(@chart_options).draw_on(@chart_front_canvas)
-        values = data.column_values(id)
+        values = data.series(id)
         return if values.compact.size == 0
         bar_width = chart_width * bar_width_ratio / values.size / (@bar_series.size + (@bar_series.size - 1) * bar_seriese_interval)
 
@@ -400,7 +400,7 @@ module DYI #:nodoc:
           next if value.nil?
           x = order_position_on_chart(margin_left, chart_width, values.size, i, x_axis_type, bar_width_ratio) + bar_width * (1 + bar_seriese_interval) * @bar_series.index(id)
           y = value_position_on_chart(margin_top, settings, value, true)
-          brush = bar_chart_brush(data[i, color_columns[id]], bar_width) if color_columns && color_columns[id]
+          brush = bar_chart_brush(data.has_field?(:color) ? data.records[i].color : color, bar_width) if data.has_field?(:color)
           brush.draw_rectangle(bar_group, [x, y], bar_width, height - margin_bottom - y)
         end
         bar_group.translate(back_translate_value[:dx] / 2, back_translate_value[:dy] / 2) if represent_3d?
@@ -409,7 +409,7 @@ module DYI #:nodoc:
       def draw_stackedbar(id, color, settings) #:nodoc:
         bar_group = Shape::ShapeGroup.new(@chart_options).draw_on(@chart_front_canvas)
 
-        values = data.column_values(id)
+        values = data.series(id)
         return if values.compact.size == 0
         bar_width = chart_width * bar_width_ratio / values.size
 
@@ -429,9 +429,17 @@ module DYI #:nodoc:
         bar_group.translate(back_translate_value[:dx] / 2, back_translate_value[:dy] / 2) if represent_3d?
       end
 
+      # @since 1.0.0
+      def chart_color(index) #:nodoc:
+        if chart_colors
+          color = chart_colors[index]
+        end
+        color || DEFAULT_CHART_COLOR[index % DEFAULT_CHART_COLOR.size]
+      end
+
       def legend_shapes #:nodoc:
         result = []
-        data_columns.each_with_index do |id, index|
+        (0...data.values_size).each_with_index do |id, index|
           result <<
             case chart_type(index)
             when :line, nil

data/lib/dyi/chart/pie_chart.rb

@@ -24,6 +24,8 @@ 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}
@@ -35,88 +37,153 @@ module DYI #:nodoc:
       opt_accessor :chart_stroke_color, {:type => :color}
       opt_accessor :chart_stroke_width, {:type => :float, :default => 1}
       opt_accessor :moved_elements, {:type => :array, :item_type => :float}
+      opt_accessor :pie_css_class, :type => :string
       opt_accessor :show_data_label, {:type => :boolean, :default => true}
+      opt_accessor :data_label_css_class, :type => :string
       opt_accessor :data_label_position, {:type => :float, :default => 0.8}
       opt_accessor :data_label_font, {:type => :font}
-      opt_accessor :data_label_format, {:type => :string, :default => "{name}\n{value}"}
+      opt_accessor :data_label_format, {:type => :string, :default => "{?name}"}
       opt_accessor :hide_data_label_ratio, {:type => :float, :default => 0.00}
+      opt_accessor :show_baloon, :type => :boolean, :default => true
+      opt_accessor :baloon_font, :type => :font
+      opt_accessor :baloon_position, {:type => :float, :default => 0.8}
+      opt_accessor :baloon_format, :type => :string, :default => "{?name}\n{?value}"
+      opt_accessor :baloon_padding, :type => :hash, :default => {}, :keys => [:vertical, :horizontal], :item_type => :length
+      opt_accessor :baloon_round, :type => :length, :default => 6
+      opt_accessor :baloon_background_color, :type => :color
+      opt_accessor :baloon_background_colors, :type => :array, :item_type => :color
+      opt_accessor :baloon_border_color, :type => :color
+      opt_accessor :baloon_border_colors, :type => :array, :item_type => :color
+      opt_accessor :baloon_border_width, :type => :length, :default => 2
+      opt_accessor :baloon_css_class, :type => :string
+      opt_accessor :animation_duration, :type => :float, :default => 0.5
 
       def back_translate_value
         {:dy => (Length.new_or_nil(_3d_settings[:dy]) || chart_radius_y.quo(2))}
       end
 
+      # @since 1.0.0
+      def get_baloon_background_color(index)
+        (baloon_background_colors && baloon_background_colors[index]) ||
+            baloon_background_color ||
+            chart_color(index).merge('white', 0.7)
+      end
+
+      # @since 1.0.0
+      def get_baloon_border_color(index)
+        (baloon_border_colors && baloon_border_colors[index]) ||
+            baloon_border_color ||
+            chart_color(index).merge('black', 0.3)
+      end
+
       private
 
       def default_center_point #:nodoc:
-        Coordinate.new(coordinate = ([width, height].min).quo(2), coordinate)
+        margin = [width - chart_radius_x * 2, height - chart_radius_y * 2].min.quo(2)
+        Coordinate.new(margin + chart_radius_x, margin + chart_radius_y)
       end
 
       def default_chart_radius_x #:nodoc:
-        [[width, height].min / 2 - Length.new(32), [width, height].min * 0.4].max
+        [width, height].min * 0.4
       end
 
       def default_chart_radius_y #:nodoc:
         represent_3d? ? chart_radius_x.quo(2) : chart_radius_x
       end
 
-      def default_csv_format #:nodoc:
-        [:$name, 0, :$color]
-      end
-
       def default_legend_point #:nodoc:
-        Coordinate.new(width < height ? [width * 0.1, width] : [height, height * 0.1])
+        if width - chart_radius_x * 2 < height - chart_radius_y * 2
+          Coordinate.new(width * 0.1, chart_radius_y * 2 + (width - chart_radius_x * 2) * 0.8)
+        else
+          Coordinate.new(chart_radius_x * 2 + (height - chart_radius_y * 2) * 0.8, height * 0.1 + Length.new(10))
+        end
       end
 
       def default_legend_format #:nodoc:
-        "{name}\t{percent}"
+        "{?name}\t{?percent}"
       end
 
       def create_vector_image #:nodoc:
+        super
         if represent_3d?
           brush = Drawing::ColumnBrush.new(back_translate_value.merge(chart_stroke_color ? {:stroke_width => chart_stroke_width, :stroke => chart_stroke_color} : {}))
         else
           brush = Drawing::Brush.new(chart_stroke_color ? {:stroke_width => chart_stroke_width, :stroke => chart_stroke_color, :stroke_miterlimit => chart_stroke_width} : {})
         end
+        attrs = if pie_css_class && !pie_css_class.empty?
+                  {:css_class => pie_css_class}
+                else
+                  {}
+                end
         @chart_canvas = Shape::ShapeGroup.draw_on(@canvas)
-        @data_label_canvas = Shape::ShapeGroup.draw_on(@canvas)
-        @legend_canvas = Shape::ShapeGroup.draw_on(@canvas)
-        total_value = data.column_values(0).inject(0.0) {|sum, value| sum + (value || 0)}
+        attrs = if data_label_css_class && !data_label_css_class.empty?
+                  {:css_class => data_label_css_class}
+                else
+                  {}
+                end
+        @data_label_canvas = Shape::ShapeGroup.draw_on(@canvas, attrs)
+        attrs = if legend_css_class && !legend_css_class.empty?
+                  {:css_class => legend_css_class}
+                else
+                  {}
+                end
+        @legend_canvas = Shape::ShapeGroup.draw_on(@canvas, attrs)
+        @legends = []
+        @sectors = []
+        draw_legend(data.records, nil)
+        total_value = data.inject(0.0) {|sum, record| sum + (record.value || 0)}
         accumulation = 0.0
         accumulations = []
         stop_index = -1
-        data.column_values(0).each_with_index do |value, i|
+        data.each_with_index do |record, i|
           accumulations.push(accumulation)
+          value = record.value
           if value && total_value > (accumulation + value) * 2 && value != 0.0
-#            brush.color = data[:$color] && data[:$color][i] || chart_color(i)
             brush.color = chart_color(i)
-            name = data.row_title(i)
-            draw_chart(brush, name, value, accumulation, total_value, i)
+            draw_chart(brush, record, accumulation, total_value, i)
             stop_index = i
           end
           accumulation += value if value
         end
-        (data.column_values(0).size - 1).downto(stop_index + 1) do |i|
-          value = data.column_values(0)[i]
+        (data.records_size - 1).downto(stop_index + 1) do |i|
+          value = (record = data.records[i]).value
           if value && value != 0.0
-#            brush.color = data[:$color] && data[:$color][i] || chart_color(i)
             brush.color = chart_color(i)
-            name = data.row_title(i)
-            draw_chart(brush, name, value, accumulations[i], total_value, i)
+            draw_chart(brush, record, accumulations[i], total_value, i)
+          end
+        end
+        @sectors.each_with_index do |sector, i|
+          @legends.each_with_index do |legend, j|
+            if i != j
+              sector.parent.add_painting_animation(:to => {:opacity => 0.35},
+                                          :duration => animation_duration,
+                                          :fill => 'freeze',
+                                          :begin_event => Event.mouseover(legend),
+                                          :end_event => Event.mouseout(legend))
+              sector.parent.add_painting_animation(:to => {:opacity => 1},
+                                          :fill => 'freeze',
+                                          :begin_event => Event.mouseout(legend))
+            end
           end
         end
-#        draw_legend(data.row_titles, nil, nil, data[:$color])
-        draw_legend(data.row_titles, nil, nil, nil)
       end
 
-      def draw_chart(brush, name, value, accumulation, total_value, index) #:nodoc:
+      def draw_chart(brush, record, accumulation, total_value, index) #:nodoc:
         canvas = Shape::ShapeGroup.draw_on(@chart_canvas)
-        brush.draw_sector(
+        attrs = {}
+        if data.has_field?(:css_class) && (css_class = record.css_class)
+          attrs[:css_class] = record.css_class
+        end
+        value = record.value
+        pie_sector = brush.draw_sector(
           canvas,
           center_point,
           chart_radius_x,
           chart_radius_y,
           accumulation * 360.0 / total_value - 90,
-          value * 360.0 / total_value)
+          value * 360.0 / total_value,
+          attrs)
+        @sectors[index] = pie_sector
 
         if moved_elements && (dr = moved_elements[index])
           canvas.translate(
@@ -126,15 +193,155 @@ module DYI #:nodoc:
 
         ratio = value.to_f.quo(total_value)
         if show_data_label?
-          legend_point = Coordinate.new(
+          label_point = Coordinate.new(
             chart_radius_x * (data_label_position + (dr || 0)) * Math.cos(((accumulation * 2.0 + value) / total_value - 0.5) * Math::PI),
             chart_radius_y * (data_label_position + (dr || 0)) * Math.sin(((accumulation * 2.0 + value) / total_value - 0.5) * Math::PI))
           Drawing::Pen.black_pen(:font => data_label_font).draw_text(
             @data_label_canvas,
-            center_point + legend_point,
-            data_label_format.gsub(/\{name\}/, name).gsub(/\{value\}/, value.to_s).gsub(/\{percent\}/, '%.1f%' % (ratio * 100.0).to_s),
-            :text_anchor => 'middle')
+            center_point + label_point,
+            format_string(data_label_format, record, total_value),
+            attrs.merge(:text_anchor => 'middle'))
         end if hide_data_label_ratio < ratio
+        draw_baloon(brush, record, accumulation, total_value, index, ratio, pie_sector)
+      end
+
+      # @since 1.0.0
+      def draw_baloon(brush, record, accumulation, total_value, index, ratio, pie_sector)
+        value = record.value
+        if show_baloon?
+          dr = moved_elements && moved_elements[index]
+          baloon_point = Coordinate.new(
+              chart_radius_x * (baloon_position + (dr || 0)) *
+                  Math.cos(((accumulation * 2.0 + value) / total_value - 0.5) * Math::PI),
+              chart_radius_y * (baloon_position + (dr || 0)) *
+                  Math.sin(((accumulation * 2.0 + value) / total_value - 0.5) * Math::PI))
+          baloon_options = {:text_anchor => 'middle', :show_border => true}
+          if data.has_field?(:css_class) && (css_class = record.css_class)
+            baloon_options[:css_class] = record.css_class
+          end
+          baloon_options[:vertical_padding] = baloon_padding[:vertical_padding] || 2
+          baloon_options[:horizontal_padding] = baloon_padding[:horizontal_padding] || 5
+          baloon_options[:background_color] = get_baloon_background_color(index)
+          baloon_options[:border_color] = get_baloon_border_color(index)
+          baloon_options[:border_width] = baloon_border_width
+          baloon_options[:border_rx] = baloon_round
+          if baloon_css_class && baloon_css_class.empty?
+            @data_label_canvas.add_css_class(baloon_css_class)
+          end
+          text = Drawing::Pen.black_pen(:font => baloon_font, :opacity => 0.0).draw_text(
+              @data_label_canvas,
+              center_point + baloon_point,
+              format_string(data_label_format, record, total_value),
+              baloon_options)
+          text.add_painting_animation(:to => {:opacity => 1},
+                                      :duration => animation_duration,
+                                      :fill => 'freeze',
+                                      :begin_event => Event.mouseover(pie_sector))
+          text.add_painting_animation(:to => {:opacity => 0},
+                                      :duration => animation_duration,
+                                      :fill => 'freeze',
+                                      :begin_event => Event.mouseout(pie_sector))
+          if @legends
+            text.add_painting_animation(:to => {:opacity => 1},
+                                        :duration => animation_duration,
+                                        :fill => 'freeze',
+                                        :begin_event => Event.mouseover(@legends[index]))
+            text.add_painting_animation(:to => {:opacity => 0},
+                                        :duration => animation_duration,
+                                        :fill => 'freeze',
+                                        :begin_event => Event.mouseout(@legends[index]))
+          end
+        end
+      end
+
+      # @since 1.0.0
+      def draw_legend(records, shapes=nil)
+        legend_canvas.translate(legend_point.x, legend_point.y)
+        if show_legend?
+          pen = Drawing::Pen.black_pen(:font => legend_font)
+          brush = Drawing::Brush.new
+          toatal = records.inject(0.0){|sum, record| sum + record.value}
+          formats = legend_format.split("\t")
+          legend_labels = []
+          records.each_with_index do |record, i|
+            legend_labels << formats.map do |format|
+                               format_string(format, record, toatal)
+                             end
+          end
+          require 'pp'
+          max_lengths = legend_labels.inject(Array.new(formats.size, 0)) do |maxs, labels|
+                          (0...formats.size).each do |i|
+                            maxs[i] = labels[i].bytesize if maxs[i] < labels[i].bytesize
+                          end
+                          maxs
+                        end
+          canvas.add_initialize_script(form_legend_labels(legend_canvas))
+          records.each_with_index do |record, i|
+            y = legend_font_size * (1.2 * (i + 1))
+            attrs = {}
+            if data.has_field?(:css_class) && (css_class = record.css_class)
+              attrs[:css_class] = record.css_class
+            end
+            group = Shape::ShapeGroup.draw_on(legend_canvas, attrs)
+            @legends << group
+            case shapes && shapes[i]
+            when Shape::Base
+              shapes[i].draw_on(group)
+            when NilClass
+              brush.color = chart_color(i)
+              brush.draw_rectangle(
+                group,
+                Coordinate.new(legend_font_size * 0.2, y - legend_font_size * 0.8),
+                legend_font_size * 0.8,
+                legend_font_size * 0.8)
+            end
+            x = legend_font_size * 0.2 + legend_font_size
+            legend_labels[i].each_with_index do |label, j|
+              formats[j] =~ /\A\{!(\w)\}/
+              case $1
+              when 's'
+                attrs = {:text_anchor => 'start'}
+                pen.draw_text(group, Coordinate.new(x, y), label, attrs)
+                x += legend_font_size * max_lengths[j] * 0.5
+              when 'm'
+                attrs = {:text_anchor => 'middle'}
+                x += legend_font_size * max_lengths[j] * 0.25
+                pen.draw_text(group, Coordinate.new(x, y), label, attrs)
+                x += legend_font_size * max_lengths[j] * 0.25
+              when 'e'
+                attrs = {:text_anchor => 'end'}
+                x += legend_font_size * max_lengths[j] * 0.5
+                pen.draw_text(group, Coordinate.new(x, y), label, attrs)
+              else
+                attrs = {}
+                pen.draw_text(group, Coordinate.new(x, y), label, attrs)
+                x += legend_font_size * max_lengths[j] * 0.5
+              end
+            end
+          end
+        end
+      end
+
+      def format_string(format, record, total_value)
+        format = format.gsub(/\A\{!(\w)\}/, '')
+        format.gsub(/\{\?((?![0-9])\w+)(:[^}]*)?\}/){|m|
+          fmt = $2 ? $2[1..-1] : nil
+          if $1 == 'percent'
+            value = record.value.quo(total_value)
+            fmt ||= '0.0%'
+          else
+            value = record.__send__($1)
+          end
+          if fmt
+            case value
+              when Numeric then value.strfnum(fmt)
+              when DateTime, Time then value.strftime(fmt)
+              else fmt % value
+            end
+          else
+            value
+          end
+        }
       end
     end
   end