dyi 0.0.0

data/lib/dyi/chart/csv_reader.rb

@@ -0,0 +1,93 @@
+# -*- 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 'csv'
+require 'date'
+require 'bigdecimal'
+require 'nkf'
+
+module DYI #:nodoc:
+  module Chart #:nodoc:
+
+    class CsvReader < ArrayReader
+      def read(path, options={})
+        options = options.dup
+        @date_format = options.delete(:date_format)
+        @datetime_format = options.delete(:datetime_format)
+        nkf_options =
+          case (options[:encode] || :utf8).to_sym
+            when :utf8 then nil
+            when :sjis then '-w -S -m0 -x --cp932'
+            when :euc then '-w -E -m0 -x --cp932'
+            when :jis then '-w -J -m0 -x'
+            when :utf16 then '-w -W16 -m0 -x'
+            else raise ArgumentError,"Unknown encode: `#{@encode}'"
+          end
+        parsed_array = 
+          if RUBY_VERSION >= '1.9'
+            CSV.parse(nkf_options ? NKF.nkf(nkf_options, IO.read(path)) : IO.read(path), :col_sep => options[:col_sep] || ',', :row_sep => options[:row_sep] || :auto)
+          else
+            CSV.parse(nkf_options ? NKF.nkf(nkf_options, IO.read(path)) : IO.read(path), options[:col_sep], options[:row_sep])
+          end
+        super(parsed_array, options)
+      end
+
+      private
+
+      def primitive_value(value, type)
+        if type.is_a?(Symbol) || type.is_a?(String)
+          case type.to_sym
+          when :string
+            value || ''
+          when :number, :decimal
+            value ? BigDecimal.new(value) : nil
+          when :float
+            value ? value.to_f : nil
+          when :integer
+            value ? value.to_i : nil
+          when :date
+            return nil if value.nil?
+            @date_format ? Date.strptime(value, @date_format) : Date.parse(value)
+          when :datetime
+            return nil if value.nil?
+            @datetime_format ? DateTime.strptime(value, @datetime_format) : DateTime.parse(value)
+          when :boolean
+            value ? true : value
+          else
+            value ? value.to_f : nil
+          end
+        else
+          value ? value.to_f : nil
+        end
+      end
+
+      def primitive_title_value(value, type=nil)
+        value
+      end
+
+      class << self
+        def read(path, options={})
+          new.read(path, options)
+        end
+      end
+    end
+  end
+end

data/lib/dyi/chart/excel_reader.rb

@@ -0,0 +1,100 @@
+# -*- 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/>.
+
+begin
+  require 'win32ole' # for Windows
+rescue LoadError
+  # do notiong
+end
+
+require 'date'
+require 'nkf'
+
+module DYI #:nodoc:
+  module Chart #:nodoc:
+
+    class ExcelReader < ArrayReader
+      OFFSET = DateTime.now.offset
+
+      def read(path, options={})
+        if defined? WIN32OLE
+          # for Windows
+          path = WIN32OLE.new('Scripting.FileSystemObject').getAbsolutePathName(path)
+          excel = WIN32OLE.new('Excel.Application')
+          book = excel.workbooks.open(path)
+          sheet = book.worksheets.item(options[:sheet] || 1)
+          range = sheet.usedRange
+          sheet_values = sheet.range(sheet.cells(1,1), sheet.cells(range.end(4).row, range.end(2).column)).value
+        else
+          # except Windows
+          raise NotImplementedError, 'win32ole is not installed'
+        end
+
+        begin
+          super(sheet_values, options)
+        ensure
+          if defined? WIN32OLE
+            book.close(false)
+            excel.quit
+            excel = sheet = nil
+          end
+          book = sheet_values = nil
+          GC.start
+        end
+        self
+      end
+
+      private
+
+      def primitive_value(value, type=nil)
+        if defined? WIN32OLE
+          # for Windows
+          case value
+          when String
+            if value =~ %r(^(\d{4})/(\d{2})/(\d{2}) (\d{2}):(\d{2}):(\d{2})$)
+              DateTime.new($1.to_i, $2.to_i, $3.to_i, $4.to_i, $5.to_i, $6.to_i, OFFSET)
+            elsif value.size == 0
+              nil
+            else
+              NKF.nkf('-w -S -m0 -x --cp932', value)
+            end
+          when Numeric, nil, true, false
+            value
+          when System::DateTime
+            # for IronRuby
+            DateTime.new(value.Year, value.Month, value.Day, value.Hour, value.Minute, value.Second, OFFSET)
+          else
+            value
+          end rescue value
+        else
+          # except Windows
+          raise NotImplementedError, 'win32ole is not installed'
+        end
+      end
+
+      class << self
+        def read(path, options={})
+          new.read(path, options)
+        end
+      end
+    end
+  end
+end

data/lib/dyi/chart/line_chart.rb

@@ -0,0 +1,468 @@
+# -*- 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:
+
+    class LineChart < Base
+      include AxisUtil
+      include Legend
+      CHART_TYPES = [:line, :area, :bar, :stackedbar]
+      attr_reader :axis_back_canvas, :chart_back_canvas, :scale_canvas, :chart_front_canvas, :axis_front_canvas, :legend_canvas
+
+      opt_accessor :chart_margins, {:type => :hash, :default => {}, :keys => [:top,:right,:bottom,:left], :item_type => :length}
+      opt_accessor :chart_colors, {:type => :array, :item_type => :color}
+      opt_accessor :chart_type, {:type => :symbol, :default => :line, :valid_values => CHART_TYPES}
+      opt_accessor :chart_types, {:type => :array, :item_type => :symbol, :valid_values => CHART_TYPES.clone.unshift('')}
+      opt_accessor :represent_3d, {:type => :boolean}
+      opt_accessor :_3d_settings, {:type => :hash, :default => {}, :keys => [:background_opacity,:dx,:dy], :item_type => :float}
+      opt_accessor :show_dropshadow, {:type => :boolean}
+      opt_accessor :dropshadow_settings, {:type => :hash, :default => {}, :keys => [:blur_std,:dx,:dy], :item_type => :float}
+      opt_accessor :x_axis_type, {:type => :symbol, :default => :range, :valid_values => [:point,:range]}
+      opt_accessor :line_width, {:type => :integer}
+      opt_accessor :bar_width_ratio, {:type => :float, :default => 0.6, :range => 0..1}
+      opt_accessor :main_y_axis, {:type => :symbol, :default => :left, :valid_values => [:left,:right]}
+      opt_accessor :axis_font, {:type => :font}
+      opt_accessor :axis_settings, {:type => :hash, :default => {}, :keys => [:max, :min, :min_scale_value, :scale_count, :scale_interval], :item_type => :integer}
+      opt_accessor :x_axis_format, {:type => :string}
+      opt_accessor :axis_format, {:type => :string}
+      opt_accessor :use_y_second_axises, {:type => :array, :item_type => :boolean}
+      opt_accessor :second_axis_settings, {:type => :hash, :default => {}, :keys => [:max, :min], :item_type => :integer}
+      opt_accessor :second_axis_format, {:type => :string, :default_method => :axis_format}
+      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 :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}
+      
+      def margin_top
+        chart_margins[:top] || Length.new(16)
+      end
+
+      def margin_right
+        chart_margins[:right] || Length.new(64)
+      end
+
+      def margin_bottom
+        chart_margins[:bottom] || Length.new(32)
+      end
+
+      def margin_left
+        chart_margins[:left] || Length.new(64)
+      end
+
+      alias __org_chart_type__ chart_type
+
+      def chart_type(index = nil)
+        if index
+          (chart_types && chart_types[index]) || __org_chart_type__
+        else
+          __org_chart_type__
+        end
+      end
+
+      def s_3d_pen_options
+        {:background_opacity => 0.3}.merge(_3d_settings)
+      end
+
+      def back_translate_value
+        {
+          :dx => (Length.new_or_nil(_3d_settings[:dx]) || Length.new(24)),
+          :dy => (Length.new_or_nil(_3d_settings[:dy]) || Length.new(-8))
+        }
+      end
+
+      def dropshadow_blur_std
+        dropshadow_settings[:blur_std] || 4
+      end
+
+      def dropshadow_dx
+        dropshadow_settings[:dx] || back_translate_value[:dx] / 2
+      end
+
+      def dropshadow_dy
+        dropshadow_settings[:dy] || back_translate_value[:dy] / 2
+      end
+
+      def use_y_second_axis?(index = nil)
+        if index
+          use_y_second_axises && use_y_second_axises[index]
+        else
+          use_y_second_axises && use_y_second_axises.any?
+        end
+      end
+
+      def chart_width
+        width - margin_left - margin_right
+      end
+
+      def chart_height
+        height - margin_top - margin_bottom
+      end
+
+      def line_chart_pen(color)
+        if represent_3d?
+          Drawing::CubicPen.new({:color => color, :width => line_width}.merge(s_3d_pen_options))
+        else
+          Drawing::Pen.new(:color => color, :width => line_width, :stroke_linecap => 'square')
+        end
+      end
+
+      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
+          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)
+        end
+      end
+
+      def area_chart_brush(color)
+        Drawing::Brush.new(:color => color)
+      end
+
+      private
+
+      def default_legend_point #:nodoc:
+        Coordinate.new(margin_left, 0)
+      end
+
+      def create_vector_image #:nodoc:
+        init_container
+
+        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)
+          @bar_series.push(i) if chart_type(i) == :bar
+        end
+        settings =
+          moderate_axis(
+            main_series_data,
+            chart_height,
+            axis_settings[:min],
+            axis_settings[:max],
+            axis_settings[:scale_count])
+        sub_settings =
+          moderate_sub_axis(
+            sub_series_data,
+            settings,
+            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
+        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
+        end
+
+        draw_axis(settings, sub_settings)
+        texts = legend_texts || data_columns.map{|i| data.column_title(i)}
+        draw_legend(texts, legend_shapes)
+      end
+
+      def init_container #:nodoc:
+#        mask = Drawing::ColorEffect::Mask.new(@canvas)
+#        mask.add_shapes(Shape::Rectangle.new(Drawing::Brush.new(:color => '#FFFFFF'), [margin_left, margin_top], chart_width, chart_height))
+        @axis_back_canvas = Shape::ShapeGroup.draw_on(@canvas) unless @axis_back_canvas
+#        @chart_front_canvas = Shape::ShapeGroup.draw_on(@canvas, :mask => "url(##{mask.id})") unless @chart_front_canvas
+        @chart_back_canvas = Shape::ShapeGroup.draw_on(@canvas) unless @chart_back_canvas
+        @scale_canvas = Shape::ShapeGroup.draw_on(@canvas) unless @scale_canvas
+        @chart_front_canvas = Shape::ShapeGroup.draw_on(@canvas) unless @chart_front_canvas
+        @axis_front_canvas = Shape::ShapeGroup.draw_on(@canvas) unless @axis_front_canvas
+        @legend_canvas = Shape::ShapeGroup.draw_on(@canvas) unless @legend_canvas
+        @chart_options = {}
+#        @chart_options[:filter] = "url(##{Drawing::Filter::DropShadow.new(@canvas, dropshadow_blur_std, dropshadow_dx, dropshadow_dy).id})" if show_dropshadow?
+        chart_clip = Drawing::Clipping.new(Shape::Rectangle.new([margin_left, margin_top], width - margin_left - margin_right, height - margin_top - margin_bottom))
+        @chart_back_canvas.set_clipping(chart_clip)
+        @chart_front_canvas.set_clipping(chart_clip)
+      end
+
+      def draw_axis(settings, sub_settings) #:nodoc:
+        line_options = {:linecap => 'square'}
+        line_pen = represent_3d? ? Drawing::CubicPen.new(line_options.merge(s_3d_pen_options)) : Drawing::Pen.new(line_options)
+        sub_pen = represent_3d? ? Drawing::Pen.new : line_pen
+        text_pen = Drawing::Pen.new(:font => axis_font)
+        text_margin = axis_font && (axis_font.draw_size.quo(4)) || Font::DEFAULT_SIZE.quo(4)
+
+        draw_y_axis(line_pen)
+        draw_x_axis(line_pen, sub_pen, text_pen, text_margin)
+        draw_scale(sub_pen, text_pen, settings, sub_settings, text_margin)
+      end
+
+      def draw_y_axis(pen) #:nodoc:
+        if use_y_second_axis? || main_y_axis == :left
+          start_point = [margin_left, height - margin_bottom]
+          end_point = [margin_left, margin_top]
+          pen.draw_line(represent_3d? ? @axis_back_canvas : @axis_front_canvas, start_point, end_point)
+        end
+
+        if use_y_second_axis? || main_y_axis == :right
+          start_point = [width - margin_right, height - margin_bottom]
+          end_point = [width - margin_right, margin_top]
+          pen.draw_line(@axis_front_canvas, start_point, end_point)
+        end
+      end
+
+      def draw_scale(line_pen, text_pen, settings, sub_settings, text_margin) #:nodoc:
+        if settings[:min] == settings[:min_scale_value] - settings[:scale_interval]
+          y = value_position_on_chart(margin_top, settings, settings[:min], true)
+          if use_y_second_axis? || main_y_axis == :left
+            text_pen.draw_text(
+              @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
+          if use_y_second_axis? || main_y_axis == :right
+            text_pen.draw_text(
+              @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
+
+        if represent_3d? && (use_y_second_axis? || main_y_axis == :left)
+          line_pen.draw_line(
+            @axis_back_canvas,
+            [margin_left, height - margin_bottom],
+            [margin_left + back_translate_value[:dx], height - margin_bottom + back_translate_value[:dy]])
+        end
+
+        sub_axis_value = sub_settings[:min_scale_value] if use_y_second_axis?
+        settings[:min_scale_value].step(settings[:max], settings[:scale_interval]) do |value|
+          y = value_position_on_chart(margin_top, settings, value, true)
+
+          if settings[:min] != value
+            if represent_3d?
+              if use_y_second_axis? || main_y_axis == :left
+                draw_y_scale_line(
+                  line_pen,
+                  [margin_left, y],
+                  [margin_left + back_translate_value[:dx], y + back_translate_value[:dy]])
+              end
+              draw_y_scale_line(
+                line_pen,
+                [margin_left + back_translate_value[:dx], y + back_translate_value[:dy]],
+                [width - margin_right + back_translate_value[:dx], y + back_translate_value[:dy]])
+              if use_y_second_axis? || main_y_axis == :right
+                draw_y_scale_line(
+                  line_pen,
+                  [width - margin_right + back_translate_value[:dx], y + back_translate_value[:dy]],
+                  [width - margin_right, y])
+              end
+            else
+              line_pen.dasharray = '2,6'
+              draw_y_scale_line(line_pen, [margin_left, y], [width - margin_right, y])
+              line_pen.dasharray = nil
+            end
+          end
+
+          if use_y_second_axis? || main_y_axis == :left
+            text_pen.draw_text(
+              @axis_back_canvas,
+              [margin_left - text_margin, y],
+              main_y_axis == :left ? value : sub_axis_value,
+              :alignment_baseline=>'middle',
+              :text_anchor=>'end',
+              :font=>axis_font,
+              :format => (main_y_axis == :left ? axis_format : second_axis_format))
+          end
+
+          if use_y_second_axis? || main_y_axis == :right
+            text_pen.draw_text(
+              @axis_front_canvas,
+              [width - margin_right + text_margin, y],
+              main_y_axis == :right ? value : sub_axis_value,
+              :alignment_baseline=>'middle',
+              :font=>axis_font,
+              :format => (main_y_axis == :right ? axis_format : second_axis_format))
+          end
+          sub_axis_value += sub_settings[:scale_interval] if use_y_second_axis?
+        end
+      end
+
+      def draw_y_scale_line(pen, left_point, right_point)
+        pen.draw_line(@scale_canvas, left_point, right_point)
+      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
+      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|
+          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_pen.draw_text(
+            @axis_front_canvas,
+            [text_x, height - margin_bottom + text_margin],
+            format_x_label(data.row_title(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)
+        end
+      end
+
+      def draw_chart(id, chart_type, color, settings) #:nodoc:
+        case chart_type
+          when :line then draw_line(id, color, settings)
+          when :area then draw_area(id, color, settings)
+          when :bar then draw_bar(id, color, settings)
+          when :stackedbar then draw_stackedbar(id, color, settings)
+        end
+      end
+
+      def draw_line(id, color, settings) #:nodoc:
+        values = data.column_values(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}
+        pen = line_chart_pen(color)
+
+        x = order_position_on_chart(margin_left, chart_width, values.size, first_index, x_axis_type)
+        y = value_position_on_chart(margin_top, settings, values[first_index], true)
+        pen.linejoin = 'bevel'
+        pen.draw_polyline(@chart_front_canvas, [x, y], @chart_options) {|polyline|
+          ((first_index + 1)...values.size).each do |i|
+            x = order_position_on_chart(margin_left, chart_width, values.size, i, x_axis_type)
+            y = value_position_on_chart(margin_top, settings, values[i], true)
+            polyline.line_to([x, y])
+          end
+        }
+        pen.linejoin = 'bevel'
+      end
+
+      def draw_area(id, color, settings) #:nodoc:
+        values = data.column_values(id)
+        return if values.compact.size == 0
+        first_index = values.each_with_index {|value, i| break i if value}
+        brush = area_chart_brush(color)
+
+        x = order_position_on_chart(margin_left, chart_width, values.size, first_index, x_axis_type)
+        y = value_position_on_chart(margin_top, settings, settings[:min], true)
+        polygone = brush.draw_polygon(@chart_front_canvas, [x, y], @chart_options) {|polygon|
+          (first_index...values.size).each do |i|
+            x = order_position_on_chart(margin_left, chart_width, values.size, i, x_axis_type)
+            y = value_position_on_chart(margin_top, settings, values[i], true)
+            polygon.line_to([x, y])
+          end
+          y = value_position_on_chart(margin_top, settings, settings[:min], true)
+          polygon.line_to([x, y])
+        }
+        polygone.translate(back_translate_value[:dx], back_translate_value[:dy]) if represent_3d?
+      end
+
+      def draw_bar(id, color, settings) #:nodoc:
+        bar_group = Shape::ShapeGroup.new(@chart_options).draw_on(@chart_front_canvas)
+        values = data.column_values(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)
+
+        brush = bar_chart_brush(color, bar_width)
+
+        values.each_with_index do |value, i|
+          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.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?
+      end
+
+      def draw_stackedbar(id, color, settings) #:nodoc:
+        bar_group = Shape::ShapeGroup.new(@chart_options).draw_on(@chart_front_canvas)
+
+        values = data.column_values(id)
+        return if values.compact.size == 0
+        bar_width = chart_width * bar_width_ratio / values.size
+
+        brush = bar_chart_brush(color, bar_width)
+
+        @stacked_values ||= []
+
+        values.each_with_index do |value, i|
+          @stacked_values[i] ||= 0
+          next if value.nil?
+          x = order_position_on_chart(margin_left, chart_width, values.size, i, x_axis_type, bar_width_ratio)
+          y = value_position_on_chart(margin_top, settings, (@stacked_values[i] += value), true)
+          bar_height = value_position_on_chart(margin_top, settings, (@stacked_values[i] - value), true) - y
+#          brush.color = data[:$color][i] if data[:$color]
+          brush.draw_rectangle(bar_group, [x, y], bar_width,  bar_height)
+        end
+        bar_group.translate(back_translate_value[:dx] / 2, back_translate_value[:dy] / 2) if represent_3d?
+      end
+
+      def legend_shapes #:nodoc:
+        result = []
+        data_columns.each_with_index do |id, index|
+          result <<
+            case chart_type(index)
+            when :line, nil
+              Shape::Line.create_on_start_end(
+                [legend_font_size * 0.2, legend_font_size * (1.2 * index + 0.8)],
+                [legend_font_size, legend_font_size * (1.2 * index + 0.8)],
+                :painting => {:stroke => chart_color(index), :stroke_width => line_width})
+            when :bar, :stackedbar
+              nil
+            when :area
+              nil
+            else
+              nil
+            end
+        end
+        result
+      end
+
+      def format_x_label(obj)
+        if x_axis_format
+          if obj.kind_of?(Numeric)
+            obj.strfnum(x_axis_format)
+          elsif obj.respond_to?(:strftime)
+            obj.strftime(x_axis_format)
+          else
+            obj.to_s
+          end
+        else
+          obj.to_s
+        end
+      end
+    end
+  end
+end