ziya 1.0.0 → 2.0.0

data/fred.rb

@@ -0,0 +1,36 @@
+# GAUGE IDEAS ??
+
+css_parser for ruby
+
+gauge = Ziya::Gauges::Base.new( :id => 'volume' )
+gauge.add( Ziya::Gauges::Support::RadialTicks.new( :id => 'ticks' ) )
+
+gauge 'volume'
+radial_ticks 'volume_ticks'
+rotate( circle( :circle_1), circle( :circle_2 ) )
+
+    
+gauge#volume {
+  x:      100;
+  y:      100;
+  radius: 35;
+}
+
+gauge#volume rotate {
+  x: 100;
+  y:  75;
+}
+
+gauge = Ziya::Gauges::Base.new( :id => "fred" )
+gauge.add( :ticks,  :volume_ticks )
+gauge.add( :circle, :circle_1 )
+gauge.add( :circle, :circle_2 )
+gauge.add( :rotate, :circle_1, :circle_2 )
+gauge.to_xml
+
+gauge#fred {
+}
+
+gauge#fred circle#volume_ticks {
+
+}

data/gauges/designs/circle.yml

@@ -0,0 +1,18 @@
+<%= gauge :base %>
+  <%= dial :circle, :circle_1 %>
+      x:              10
+      y:              20
+      radius:         30
+      fill_alpha:      0
+      line_thickness:  5
+      
+  <%= dial :text, :title %>
+      rotation: -90
+      size:      78
+      alpha:     10
+      x:        -15
+      y:        300
+      color:    ffffff
+      width:    300
+      text:     Hello World
+      

data/gauges/designs/signal.yml

@@ -0,0 +1,14 @@
+<%= gauge :signal %>
+  <%= dial :text, :signal %>
+      x:     20
+      y:     30
+      width: 40
+      size:  16 
+      align: center 
+      color: <%= colorizer( options[:signal] ) %>
+      text:  <%= options[:signal] %>
+
+# show current signal
+<%= signal_indicator( options[:x], options[:y], 20, 30, 10, 0, 360, 10, 20, "88ff00" ) %>
+# shows delta from previous signal
+<%= delta_indicator( options[:x]+35, options[:y]-22 ) %>

data/gauges/designs/thermo.yml

@@ -0,0 +1,119 @@
+# -----------------------------------------------------------------------------
+# Thermometer design
+# -----------------------------------------------------------------------------  
+<%= gauge :thermo %>
+  # -----------------------------------------------------------------------------
+  # Gauge Title  
+  <%= dial :text, :gauge_title %>
+      rotation: -90
+      size:      75
+      alpha:     10
+      x:        <%= options[:x] - 150 %>
+      y:        <%= options[:y] + 270 %>
+      color:    ffffff
+      width:    300
+      text:     <%= options[:title] %>
+    
+  # -----------------------------------------------------------------------------
+  # Thermo tube
+  <%= dial :rect, :neck %>
+      x:              <%= options[:x] + 20 %>
+      y:              <%= options[:y] + 20 %>
+      height:         150
+      width:          40  
+      fill_alpha:     20
+      fill_color:     <%= options[:gauge_color] %>
+      line_thickness: 8
+
+  # -----------------------------------------------------------------------------
+  # Thermo bottom
+  <%= dial :circle, :vase %>
+      x:              <%= options[:x] + 40  %>
+      y:              <%= options[:y] + 190 %>
+      radius:         48
+      line_thickness: 8
+      fill_color:     <%= options[:gauge_color] %>
+      fill_alpha:     100
+
+  # main
+  <%= dial :circle, :vase_main %>
+      radius:     40
+      x:          <%= options[:x] + 40 %>
+      y:          <%= options[:y] + 190 %>
+      fill_color: <%= options[:gauge_color] %>
+
+  # reflection
+  <%= dial :circle, :vase_reflection_1 %>
+      x:          <%= options[:x] + 40 %>
+      y:          <%= options[:y] + 190 %>
+      radius:     27
+      fill_alpha: 50
+      fill_color: ffff00
+
+  # inside
+  <%= dial :circle, :vase_reflection_2 %>
+      x:          <%= options[:x] + 35 %>
+      y:          <%= options[:y] + 190 %>  
+      radius:      28
+      fill_color: <%= options[:gauge_color] %>
+
+  # -----------------------------------------------------------------------------
+  # Scale Legends
+  <%= dial :text, :legend %>
+      x:     <%= options[:x] %>
+      y:     <%= options[:y] %>
+      size:  14
+      color: cccccc
+      width: 200
+      text:  C               F
+
+  # degree
+  <%= dial :circle, :degrees %>
+      x:              <%= options[:x] %>
+      y:              <%= options[:y] + 5 %>
+      radius:         2
+      fill_alpha:     0
+      line_color:     cccccc
+      line_thickness: 1
+
+  # farenheit
+  <%= dial :circle, :farenheit %>
+      x:              <%= options[:x] + 65 %>
+      y:              <%= options[:y] + 5 %>
+      radius:         2
+      fill_alpha:     0
+      line_color:     cccccc
+      line_thickness: 1
+  
+  # -----------------------------------------------------------------------------
+  # Current Temperature
+  <%= dial :scale, :animation %>
+      x:               <%= options[:x] + 40 %>
+      y:               <%= options[:y] + 133 %>
+      direction:       vertical  
+      step:            5
+      start_scale:     100
+      end_scale:       <%= options[:end_scale] %> 
+      shake_span:      1
+      shake_frequency: 10
+      shadow_alpha:    0
+      <%= dials %>
+        <%= dial :rect, :due_point %>
+            x:      <%= options[:x] + 24 %>
+            y:      <%= options[:y] + 32 %>
+            height: 100
+            width:   32
+            fill_color: <%= options[:gauge_color] %>
+
+  # hides to of thermo base circle
+  <%= dial :rect, :z_patch %>
+      x:       <%= options[:x] + 24 %>
+      y:       <%= options[:y] + 132 %>
+      height:  30
+      width:   32     
+      fill_alpha: 100
+      # fill_color: ff0000
+      fill_color: <%= options[:gauge_color] %>
+      
+<%= draw_celsius_scale( -10, 50 ) %>
+<%= draw_farenheit_scale( 20, 120 ) %>

data/gauges/designs/title.yml

@@ -0,0 +1,11 @@
+<%= gauge :base %>
+  <%= dial :text, :title %>
+      rotation: -90
+      size:      78
+      alpha:     10
+      x:        -15
+      y:        300
+      color:    ffffff
+      width:    300
+      text:     Hello World
+      

data/lib/ziya.rb

@@ -11,7 +11,7 @@ unless defined? Ziya
     PATH    = ::File.dirname(LIBPATH) + ::File::SEPARATOR
                
     def self.default_configuration
-      { :themes_dir => File.join( File.dirname(__FILE__), %w[.. themes] ),
+      { :themes_dir => File.join( File.dirname(__FILE__), %w[.. charts themes] ),
         :log_file   => $stdout,
         :log_level  => :info }
     end
@@ -22,8 +22,14 @@ unless defined? Ziya
       @config = default_configuration.merge( opts )
       @logger = opts[:logger] if opts[:logger]
 
-      # Verify existance of themes and helper dirs if any
-      raise "Unable to find themes directory `#{themes_dir}" unless File.exists?( themes_dir )
+      # Verify existance of themes, designs and helper dirs if any
+      if themes_dir
+        raise "Unable to find themes directory `#{themes_dir}" unless File.exists?( themes_dir )
+      end
+
+      if designs_dir
+        raise "Unable to find designs directory `#{designs_dir}" unless File.exists?( designs_dir )
+      end
       
       if helpers_dir
         raise "Unable to find helper directory `#{helpers_dir}" unless File.exists?( helpers_dir )
@@ -31,8 +37,9 @@ unless defined? Ziya
       
       # Add the ziya/lib to the ruby path...
       $: << libpath
-      Ziya.require_all_libs_relative_to __FILE__                                       
-      dump
+      Ziya.require_all_libs_relative_to __FILE__
+      
+      dump if config[:log_level] == :debug
     end
 
     # ZiYa configuration
@@ -49,6 +56,11 @@ unless defined? Ziya
     def self.themes_dir
       config[:themes_dir]
     end
+
+    # the gauges designs root directory location
+    def self.designs_dir
+      config[:designs_dir]
+    end
     
     # Debug                        
     def self.dump #:nodoc:

data/lib/ziya/charts/area.rb

@@ -1,11 +1,16 @@
 # -----------------------------------------------------------------------------
 # Generates necessary xml for area chart 
+#
+# Author: Fernand
 # -----------------------------------------------------------------------------
 require 'ziya/charts/base'
 
 module Ziya::Charts
   class Area < Base
-    def initialize( license=nil, chart_id=nil)
+    # Creates an area chart
+    # <tt>:license</tt>::  the XML/SWF charts license
+    # <tt>:chart_id</tt>:: the name of the chart style sheet.        
+    def initialize( license=nil, chart_id=nil )
       super( license, chart_id )
       @type = "area"      
     end

data/lib/ziya/charts/area_threed.rb

@@ -0,0 +1,16 @@
+# -----------------------------------------------------------------------------
+# Generates necessary xml for a 3d area chart
+# 
+# Author: Fernand
+# -----------------------------------------------------------------------------
+module Ziya::Charts
+  class AreaThreed < Base
+    # Creates a 3d area chart
+    # <tt>:license</tt>::  the XML/SWF charts license
+    # <tt>:chart_id</tt>:: the name of the chart style sheet.              
+    def initialize( license=nil, chart_id=nil )
+      super( license, chart_id )
+      @type = "3d area"      
+    end
+  end
+end

data/lib/ziya/charts/bar.rb

@@ -1,11 +1,16 @@
 # -----------------------------------------------------------------------------
-# Generates necessary xml for a StackColumn chart
+# Generates necessary xml for a Bar chart
+#
+# Author: Fernand
 # -----------------------------------------------------------------------------
 module Ziya::Charts
   class Bar < Base
-    def initialize( license=nil, chart_id=nil)
+    # Creates a bar chart
+    # <tt>:license</tt>::  the XML/SWF charts license
+    # <tt>:chart_id</tt>:: the name of the chart style sheet.      
+    def initialize( license=nil, chart_id=nil )
       super( license, chart_id )
-      @type = "bar"      
+      @type = "bar"
     end
   end
 end

data/lib/ziya/charts/base.rb

@@ -12,20 +12,29 @@
 require 'ziya/helpers/base_helper'
 require 'yaml'
 
+# TODO Figure out the equiv require_dep for merb if any ??
+# TODO Refact and clean up. 
 module Ziya::Charts
+  # The mother ship of all charts. This class figures out how to generate the 
+  # correct xml to render the chart on the client side. This class handles loading
+  # style sheets and chart helper for the helper directory specified during 
+  # initialization.
   class Base
+    # blee blee
     include Ziya::Helpers::BaseHelper
     
     # =========================================================================                
     protected      
       # defines the various chart components
-      def self.declare_components
-        @components = [:axis_category, :axis_ticks, :axis_value, :chart_rect, 
-                       :chart_border, :chart_grid_h, :chart_grid_v, 
-                       :chart_transition, :chart_value, :legend_rect, 
-                       :legend_transition, :legend_label, :draw, :series_color, 
-                       :series_gap, :series_switch, :series_explode, :chart_pref, 
-                       :live_update, :link_data, :link]                              
+      def self.declare_components # :nodoc:
+        @components = [
+          :axis_category, :axis_ticks, :axis_value, 
+          :chart_rect, :chart_border, :chart_grid_h, :chart_grid_v,
+          :chart_transition, :chart_label, :chart_guide, :legend,
+          :filter, :draw, 
+          :series_color, :series_gap, :series_switch, :series_explode, 
+          :chart_pref, :scroll,
+          :update, :link_data, :link]                              
         @components.each { |a| attr_accessor a }      
       end    
       declare_components
@@ -33,44 +42,44 @@ module Ziya::Charts
     # =========================================================================    
     public
     
-    attr_accessor :license, :id, :theme, :options, :size
-    attr_reader   :type
+    attr_accessor :license, :id, :theme, :options, :size # :nodoc:
+    attr_reader   :type # :nodoc:
 
-    # -------------------------------------------------------------------------
-    # Create a new chart.
-    # license  - the XML/SWF charts license
-    # title    - the chart title
-    # chart_id - the id of the chart used to associate a style with the chart.
-    # If chart_id is specified the framework will attempt to load the chart styles
+    # create a new chart.
+    # <tt>:license</tt>::  the XML/SWF charts license
+    # <tt>:chart_id</tt>:: the name of the chart style sheet.
+    # NOTE: If chart_id is specified the framework will attempt to load the chart styles
     # from public/themes/theme_name/chart_id.yml 
     def initialize( license=nil, chart_id=nil ) 
       @id      = chart_id
       @license = license
       @options = {}
+      @series  = []
       @theme   = default_theme
       initialize_components
       load_helpers( Ziya.helpers_dir ) if Ziya.helpers_dir
     end
                 
     # class component accessor...
-    def self.components
+    def self.components # :nodoc:
       @components
     end
     
     # -------------------------------------------------------------------------
     # Default ZiYa theme
-    def default_theme
+    def default_theme # :nodoc:
       File.join( Ziya.themes_dir, %w[default] )
     end
     
     # -------------------------------------------------------------------------
     # Load up ERB style helpers
-    def load_helpers( helper_dir )      
+    def load_helpers( helper_dir ) # :nodoc:    
       Dir.foreach(helper_dir) do |helper_file| 
         next unless helper_file =~ /^([a-z][a-z_]*_helper).rb$/
         Ziya.logger.debug( ">>> ZiYa loading custom helper `#{$1}" )        
-        require_dependency File.join(helper_dir, $1)
-        helper_module_name = $1.to_s.gsub(/\/(.?)/) { "::" + $1.upcase }.gsub(/(^|_)(.)/) { $2.upcase }
+        require_dependency File.join(helper_dir, $1)        
+        helper_module_name = "Ziya::" + $1.gsub(/(^|_)(.)/) { $2.upcase }        
+        # helper_module_name = $1.to_s.gsub(/\/(.?)/) { "::" + $1.upcase }.gsub(/(^|_)(.)/) { $2.upcase }
         # if Ziya::Helpers.const_defined?(helper_module_name)
         Ziya.logger.debug( "Include module #{helper_module_name}")
         Ziya::Charts::Base.class_eval("include #{helper_module_name}") 
@@ -78,14 +87,14 @@ module Ziya::Charts
       end
     end    
                     
-    # -------------------------------------------------------------------------
     # Add chart components such as x and y axis labels, data points and chart 
     # labels.     
     # 
     # Example:
+    #   my_chart = Ziya::Charts::Bar.new
     #   my_chart.add( :axis_category_text, ['2004', '2005', '2006'] ) 
     #   my_chart.add( :series, 'series A', [ 10, 20, 30], [ '10 dogs', '20 cats', '30 rats'] )
-    #   my_chart.add( :axis_value_text, [ 'my dogs', 'my cats', 'my rats'] )
+    #   my_chart.add( :axis_value_label, [ 'my dogs', 'my cats', 'my rats'] )
     #   my_chart.add( :user_data, :mykey, "Fred" )
     #
     #   This will display a bar chart with x axis ticks my dogs, my cats, my fox and
@@ -97,28 +106,30 @@ module Ziya::Charts
     # <tt>:axis_category_text</tt>::   Array of strings representing the x/y axis
     #                                  ticks dependending on the chart type. This 
     #                                  value is required.
+    # <tt>:axis_category_label</tt>::  Array of strings representing the x axis
+    #                                  labels. This is supported only for Scatter and Bubble charts.
+    #                                  This value is optional. Specify nil for no label change.    
     # <tt>:series</tt>::               Specifies the series name and chart data points.
     #                                  The series name will be used to display chart legends.
     #                                  You must have at least one of these tag defined.
     #                                  You may also specify an array of strings to identifies the 
     #                                  custom labels that will be used on top of the chart 
-    #                                  elements.                                  
-    # <tt>:axis_value_text</tt>::      Array of strings representing the ticks on the x/y
+    #                                  elements
+    # <tt>:axis_value_label</tt>::     Array of strings representing the ticks on the x/y
     #                                  axis depending on the chart type. This is symmetrical
-    #                                  to the <tt>axis_category_text</tt> tag for the opposite
-    #                                  chart axis.     
+    #                                  to the <tt>axis_category_label</tt> tag for the opposite
+    #                                  chart axis. Specify nil for no label change.
     # <tt>:user_data</tt>::            Used to make user data available to the ERB templates in
     #                                  the chart stylesheet yaml file. You must specify a key symbol
     #                                  and an ad-hoc value. The key will be used with the @options
     #                                  hash to access the user data.  
-    # <tt>:composites</tt>::           Embeds multiple charts within the given chart.                                 
+    # <tt>:composites</tt>::           Embeds multiple charts within the given chart via the draw image component.
     # <tt>:chart_types</tt>::          Specify the chart types per series. This option should                        
     #                                  only be used with Mixed Charts !!    
     # <tt>:theme</tt>::                Specify the use of a given theme
     #
-    # TODO Validation categories = series, series = labels, etc...
-    # BOZO !! If you have a series you'll need to define an axis_category for it
     def add( *args )
+      # TODO Validation categories = series, series = labels, etc...
       directive = args.shift
       case directive
         when :axis_category_text
@@ -126,26 +137,29 @@ module Ziya::Charts
           raise ArgumentError, "Must specify an array of categories" if categories.empty?
           categories.insert( 0, nil )
           @options[directive] = categories
+        when :axis_category_label
+          labels = args.first.is_a?(Array) ? args.shift : []
+          raise ArgumentError, "Must specify an array of category labels" if labels.empty?
+          @options[directive] = labels          
         when :composites
           composites = args.first.is_a?(Array) ? args.shift: []
           raise ArgumentError, "Must specify an array of urls for the composite chart(s)" if composites.empty?
           @options[directive] = composites
-        when :axis_value_text
+        when :axis_value_label
           values = args.first.is_a?(Array) ? args.shift : []
           raise ArgumentError, "Must specify an array of values" if values.empty?
           @options[directive] = values
         when :series
           legend = args.first.is_a?(String) ? args.shift : ""
           raise ArgumentError, "Must specify a series name" if legend.empty?
-          points = args.first.is_a?(Array) ? args.shift : []
-          raise ArgumentError, "Must specify data points" if points.empty?
-          points.insert( 0, legend )
-          labels      = args.first.is_a?(Array) ? args.shift : []
-          count       = "_#{sprintf( '%04d', next_series_count )}_#{legend}"
-          series_name = "series#{count}"
-          labels_name = "labels#{count}" unless labels.empty?
-          @options[series_name.to_sym] = points
-          @options[labels_name.to_sym] = labels unless labels.empty?
+          if args.first.is_a?( Array )
+            points = args.shift || []
+            raise ArgumentError, "Must specify an array of data points" if points.empty?
+            points.insert( 0, legend )
+            @series << points
+          else
+            raise ArgumentError, "Must specify an array of data points"
+          end
         when :user_data
           key = args.first.is_a?(Symbol) ? args.shift : ""
           raise ArgumentError, "Must specify a key" if key.to_s.empty?
@@ -155,41 +169,29 @@ module Ziya::Charts
         when :styles
           styles = args.first.is_a?(String) ? args.shift : ""
           raise ArgumentError, "Must specify a set of styles" if styles.to_s.empty?          
-          @options[:styles] = styles   
+          @options[directive] = styles   
         when :chart_types
           types = args.first.is_a?(Array) ? args.shift : []
           raise ArgumentError, "Must specify a set of chart types" if types.to_s.empty?          
-          @options[:chart_types] = types                        
+          @options[directive] = types                        
         when :theme
           theme = args.first.is_a?(String) ? args.shift : ""
           raise ArgumentError, "Must specify a theme name" if theme.to_s.empty?          
           @theme = "#{Ziya.themes_dir}/#{theme}"
         else raise ArgumentError, "Invalid directive must be one of " + 
-                                 ":axis_category, :axis_value, :series, :user_data"
+                                 ":axis_category_text, :axis_value, :series, :user_data"
       end 
     end
-        
-    # -------------------------------------------------------------------------
-    # Set up theme for overall look and feel
-    # <tt>theme_name</tt> the name of the directory that contains the chart styles 
-    def self.theme( theme_name )
-      @theme = "#{Ziya.themes_dir}/#{theme_name}"
-    end
-    
-    # -------------------------------------------------------------------------
-    # Return the local theme if set or the global theme otherwise
-    def theme
-      @theme || @@theme
-    end
-        
-    # ---------------------------------------------------------------------------
-    # Spews the graph specification to xml  
+                
+    # spews the graph specification to a string
     # <tt>:partial</tt>::  You can specify this option to only update parts of the charts
     #                      that have actually changed. This is useful for live update and
     #                      link update where you may not need to redraw the whole chart.
     def to_s( options={} )
       @partial = options[:partial] || false
       @xml     = Builder::XmlMarkup.new
+      # Forces utf8 encoding on xml stream
+      @xml.instruct! :xml, :version => "1.0", :encoding => "UTF-8"
       @xml.chart do
         @xml.license( @license ) unless @license.nil?
         if !@type.nil?
@@ -203,23 +205,13 @@ module Ziya::Charts
         setup_series
       end
       @xml.to_s.gsub( /<to_s\/>/, '' )
-    end                                   
-    
-    # -------------------------------------------------------------------------
-    # Synonym for to_s
+    end                                       
+    # dumps the chart design to xml for client side consumption
     alias to_xml to_s  
                             
     # =========================================================================
     private
 
-    # -------------------------------------------------------------------------
-    # Make sure series appear in the right order
-    def next_series_count
-      count = 1
-      @options.keys.each{ |k| count+=1 unless k.to_s.index( "series_").nil? }
-      count
-    end
-
     # -------------------------------------------------------------------------
     # Inflate object state based on object hierarchy
     def setup_state( state )
@@ -239,6 +231,7 @@ module Ziya::Charts
         file_name = "#{theme}/#{instance}" unless instance.nil?
         Ziya.logger.debug ">>> Ziya attempt to load style sheet file '#{file_name}"        
         yml = IO.read( "#{file_name}.yml" )
+# Ziya.logger.debug( yml )        
         load = YAML::load( erb_render( yml ) )
         Ziya.logger.info ">>> ZiYa [loading styles] -- #{file_name}.yml"        
         return load
@@ -260,120 +253,188 @@ module Ziya::Charts
                               
     # -------------------------------------------------------------------------
     # Generates xml element for given data set
-    def gen_data_points( series_name )
-      value = @options[series_name]
+    # TODO Lame ! Refact...
+    def gen_data_points( series_name, labels=nil )
+      values  = @options[series_name]
+      labels.insert( 0, nil ) if labels
       @xml.row do
-        if value.respond_to? :each
-          value.each do |c|            
-            @xml.null if c.nil?
-            @xml.string( c ) if c.instance_of? String 
-            @xml.number( c ) if c.respond_to? :zero?
+        if values.respond_to? :each
+          values.each do |c|
+            if c.nil?
+              @xml.null 
+            elsif c.instance_of? String 
+              if labels and !labels.empty?
+                label = labels.shift                
+                if label
+                  @xml.string( :label => label ) { |x| x.text!( c ) }
+                else
+                  @xml.string( c )
+                end
+              else
+                @xml.string( c )
+              end
+            elsif c.respond_to? :zero?
+              if labels and !labels.empty?
+                label = labels.shift
+                if label
+                  @xml.number( :label => label ) { |x| x.text!( c.to_s ) } 
+                else
+                  @xml.number( c )
+                end
+              else
+                @xml.number( c )
+              end
+            end
           end
         else
-          @xml.string( value )
+          @xml.string( values )
         end
       end              
     end
             
-    # -------------------------------------------------------------------------
-    # Generates custom axis values
-    def gen_axis_value_text( values )
-      return if values.nil? or values.empty?
-      @xml.axis_value_text do 
-        values.each { |v| @xml.string( v ) }
-      end
-    end
+    # # -------------------------------------------------------------------------
+    # # Generates custom axis values
+    # def gen_axis_value_text( values )
+    #   return if values.nil? or values.empty?
+    #   @xml.axis_value_text do 
+    #     values.each { |v| @xml.string( v ) }
+    #   end
+    # end
         
+    # # -------------------------------------------------------------------------
+    # # Check if the series are named
+    # def named_series?( names )
+    #   names.each do |name|
+    #     next unless name.to_s.index( 'series_' )
+    #     return @options[name][0].instance_of?(String) if @options[name] and !@options[name].empty?
+    #   end
+    #   false
+    # end
+    
+    # # -------------------------------------------------------------------------
+    # # Check if the options have custom labels ie :label_xxx tag
+    # def has_labels( names )
+    #   names.each do |name|
+    #     next unless name.to_s.index( 'labels_' )
+    #     return @options[name].size if @options[name] and !@options[name].empty?
+    #   end
+    #   0
+    # end    
+    
+    # # -------------------------------------------------------------------------
+    # # Generates custom labels
+    # def gen_labels( series_name, is_default=false )
+    #   cltn  = @options[series_name]
+    #   cltn.insert( 0, nil ) unless is_default
+    #   @xml.row do        
+    #     cltn.each { |c| ((c.nil? or c.to_s.empty?) ? @xml.null : @xml.string( c )) }
+    #   end              
+    # end    
+    
+    # # ------------------------------------------------------------------------
+    # # Generates default series labels
+    # def gen_default_labels( size )
+    #   labels = []
+    #   size.times { |i| labels << nil }
+    #   @xml.row do        
+    #     labels.each { |c| @xml.null }
+    #   end     
+    # end                
+
+    # ------------------------------------------------------------------------
+    # generates chart data row
+    # TODO Validate options !!
+    def gen_row_data( value, opts=nil )
+      if value.instance_of? String
+        gen_string_data( value, opts )
+      elsif value.respond_to? :zero?
+        gen_number_data( value, opts )
+      end        
+    end
+    
     # -------------------------------------------------------------------------
-    # Check if the series are named
-    def named_series?( names )
-      names.each do |name|
-        next unless name.to_s.index( 'series_' )
-        return @options[name][0].instance_of?(String) if @options[name] and !@options[name].empty?
+    # generates string chart_value
+    def gen_string_data( value, opts )
+      if opts
+        @xml.string( opts ) { |x| x.text!( value ) }
+      else
+        @xml.string( value )
       end
-      false
     end
     
     # -------------------------------------------------------------------------
-    # Check if the options have custom labels ie :label_xxx tag
-    def has_labels( names )
-      names.each do |name|
-        next unless name.to_s.index( 'labels_' )
-        return @options[name].size if @options[name] and !@options[name].empty?
+    # generates number chart_value
+    def gen_number_data( value, opts )
+      if opts
+        @xml.number( opts ) { |x| x.text!( value.to_s ) }
+      else
+        @xml.number( value )
       end
-      0
-    end    
+    end
     
     # -------------------------------------------------------------------------
-    # Generates custom labels
-    def gen_labels( series_name, is_default=false )
-      cltn  = @options[series_name]
-      cltn.insert( 0, nil ) unless is_default
-      @xml.row do        
-        cltn.each { |c| ((c.nil? or c.to_s.empty?) ? @xml.null : @xml.string( c )) }
-      end              
-    end    
-    
-    # ------------------------------------------------------------------------
-    # Generates default series labels
-    def gen_default_labels( size )
-      labels = []
-      size.times { |i| labels << nil }
-      @xml.row do        
-        labels.each { |c| @xml.null }
-      end     
-    end                
+    # generates chart data points    
+    # BOZO !! Check args on hash
+    def gen_chart_data( series )
+      @xml.row do
+        series.each do |row|      
+          if row.nil?
+            @xml.null 
+          elsif row.instance_of? Hash
+            value = row.delete( :value )
+            gen_row_data( value, row )
+          else
+            gen_row_data( row )
+          end
+        end
+      end        
+    end
     
     # -------------------------------------------------------------------------
     # Lay down graph data points and labels if any
     # TODO Validate series sizes/label sizes
     def setup_series
-      keys = @options.keys.sort { |a,b| a.to_s <=> b.to_s }
-      named_series = named_series?( keys )
+      raise "You must specify an axis_category_text with your series." if !@series.empty? and ! @options[:axis_category_text]
       
-      raise "You must specify an axis_category_text with your series." if named_series and ! @options[:axis_category_text]
-      
-      unless @options[:axis_category_text].nil?
+      if @options[:axis_category_text]
         @xml.chart_data do 
-          # Setup axis categories        
-          # @options[:axis_category_text].insert( 0, nil ) if named_series
           gen_data_points( :axis_category_text )
-          keys.each do |k| 
-            gen_data_points( k ) unless k.to_s.index( 'series_' ).nil?
+          # render xml for each series
+          @series.each do |series|
+            gen_chart_data( series )
           end
         end  
       end
-
-      size = has_labels( keys )
-      if size > 0 
-        @xml.chart_value_text do
-          labels = []
-          (1..(size-1)).each { |i| labels << '' }
-          @options[:labels] = labels
-          gen_labels( :labels, true )
-        
-          # Generates series labels if specified
-          keys.each do |k|
-            next unless k.to_s.index( /^series/ )
-            label  = k.to_s.gsub( /series/, 'labels' ).to_sym
-            unless @options[label].nil?
-              gen_labels( label ) 
-            else
-              gen_default_labels( size )
-            end
+      
+      # display category labels if any
+      if @options[:axis_category_label]
+        @xml.axis_category_label do
+          @options[:axis_category_label].each do |label|
+            label ? @xml.string( label ) : @xml.null
           end
-        end    
+        end
       end
+      
+      # display axis value labels if any
+      if @options[:axis_value_label]
+        @xml.axis_value_label do
+          @options[:axis_value_label].each do |label|
+            label ? @xml.string( label ) : @xml.null
+          end
+        end
+      end
+      
     end
     
     # -------------------------------------------------------------------------
     # Walk up class hierarchy to find chart inheritance classes
     def ancestors
-      excludes = [ "Kernel", "Object", "CommonUtils" ]
       ancestors = self.class.ancestors.reverse
-      list = []
-      ancestors.each { |a| list << a unless excludes.include? a.to_s }
-      list
+      allow = false
+      ancestors.map do |k| 
+        allow = true if k == Ziya::Charts::Base
+        k if allow
+      end.compact!
     end
     
     # -------------------------------------------------------------------------
@@ -407,10 +468,6 @@ module Ziya::Charts
     # Generates xml for look and feel data
     def setup_lnf
       load_lnf
-      if @options[:axis_value_text] and ! @options[:axis_value_text].empty?
-        gen_axis_value_text( @options[:axis_value_text] )
-      end
-      
       unless @partial
         Base.components.each do |comp|          
           next unless self.send( comp ).configured? # => Don't include non configured components