gruff 0.1.2 → 0.2.3

data/lib/CocoaMagick.rb

@@ -0,0 +1,311 @@
+# CocoaMagick.rb
+#   Tim Burks / RubyCocoa Resources http://www.rubycocoa.com
+#
+# This is a quick-and-dirty replacement for RMagic written specifically 
+# for Geoffrey Grosenbach's "gruff" graphing package.
+# It uses RubyCocoa and the Cocoa API to draw the elements of gruff graphs.
+# It is FAR from comprehensive, but works for nearly all of the test cases 
+# distributed with gruff. Tested with gruff 0.1.2.  
+#
+# To use, change "require 'RMagick'"to "require 'CocoaMagick'" in gruff/base.rb.
+# You also must have RubyCocoa installed, preferably the most recent version.
+# This means you must also be running on a Mac, preferably with OS X 10.4 or later. 
+# Due to a Cocoa limitation, this script must either be run by the user currently 
+# logged into the console or as root.
+#
+# For help with RubyCocoa, visit "RubyCocoa Resources" at www.rubycocoa.com.
+# For more on gruff, see http://nubyonrails.com/pages/gruff
+# 
+require 'osx/cocoa'
+
+def log(str)
+  puts str if false
+end
+
+class OSX::NSImage
+  def writePNG(filename)
+    bits = OSX::NSBitmapImageRep.alloc.initWithData(self.TIFFRepresentation)
+    data = bits.representationUsingType_properties(OSX::NSPNGFileType, nil)
+    data.writeToFile_atomically(filename, false)
+  end
+end
+
+class OSX::NSColor
+  def self.colorWithName(name) 
+    log "colorWithName #{name}" 
+    if name[0..0] == "#" 
+      r = eval("0x"+name[1..2]) / 256.0
+      g = eval("0x"+name[3..4]) / 256.0
+      b = eval("0x"+name[5..6]) / 256.0
+      colorWithDeviceRed_green_blue_alpha(r,g,b,1)
+    elsif name == "transparent" 
+      OSX::NSColor.blackColor.colorWithAlphaComponent(0.0)
+    elsif name == "grey" 
+      OSX::NSColor.colorWithDeviceRed_green_blue_alpha(0.5,0.5,0.5,1)
+    else
+      eval("OSX::NSColor.#{name}Color")
+    end
+  end
+end
+
+module Magick
+  class Draw
+    attr_accessor :pointsize, :fill, :stroke, :font_weight, :gravity, :font, 
+      :stroke_color, :fill_color, :stroke_width, :dasharray
+    def stroke_and_fill(path)
+      @stroke_color.colorWithAlphaComponent(@stroke_opacity).set
+      path.stroke
+      @fill_color.colorWithAlphaComponent(@fill_opacity).set
+      path.fill
+    end 
+    def initialize
+      @fill = "white" 
+      @pointsize = 18
+      @stroke_opacity = 1
+      @fill_opacity = 1
+      @stroke_width = 1
+      @stroke_color = OSX::NSColor.colorWithName("grey")
+      @fill_color = OSX::NSColor.colorWithName("grey")
+      @stack = []
+      OSX::NSBezierPath.setDefaultLineJoinStyle(OSX::NSRoundLineJoinStyle)
+      OSX::NSBezierPath.setDefaultLineWidth(1)
+    end
+    def push
+      log "Draw.push" 
+      @stack.push({ # add more if needed
+        :fill_color => @fill_color, 
+        :stroke_color => @stroke_color, 
+        :dasharray => @dasharray, 
+        :dashcount => @dashcount,
+        :stroke_width => @stroke_width
+      })
+      self
+    end
+    def pop
+      log "Draw.pop"  
+      hash = @stack.pop
+      hash.keys.each {|key| self.instance_variable_set("@"+key.to_s, hash[key])}
+      self
+    end
+    def scale(x,y)
+      log "scale #{x} #{y}" 
+      @scalex = x
+      @scaley = y
+      self
+    end
+    def string_attributes
+      attributes = OSX::NSMutableDictionary.alloc.initWithCapacity_(10)
+      attributes.setObject_forKey(OSX::NSColor.colorWithName(@fill), 
+        OSX.NSForegroundColorAttributeName)
+      if @font_weight == BoldWeight
+        attributes.setObject_forKey(OSX::NSFont.boldSystemFontOfSize(@pointsize), 
+          OSX.NSFontAttributeName) 
+      else
+        attributes.setObject_forKey(OSX::NSFont.systemFontOfSize(@pointsize), 
+          OSX.NSFontAttributeName) 
+      end     
+      attributes
+    end  
+    def get_type_metrics(a,text)
+      log "get_type_metrics #{a} #{text.inspect}" 
+      attributes = string_attributes()
+      metrics = TypeMetric.new
+      size = OSX::NSString.stringWithString(text).sizeWithAttributes(attributes)
+      metrics.width = size.width
+      metrics
+    end
+    def annotate(image,width,height,x,y,text)
+      log "annotate #{image} #{width} #{height} #{x} #{y} #{text}" 
+      attributes = string_attributes()      
+      string = OSX::NSString.stringWithString(text)
+      size = string.sizeWithAttributes(attributes) 
+      if @gravity == EastGravity or @gravity == SouthEastGravity or @gravity == NorthEastGravity
+        x = x + width - size.width/2
+      elsif @gravity == CenterGravity or @gravity == NorthGravity or @gravity == SouthGravity
+        x = x + width/2 - size.width/2 
+      end
+      if @gravity == NorthGravity or @gravity == NorthEastGravity or @gravity == NorthWestGravity
+        y = y + height - size.height
+      elsif @gravity == CenterGravity or @gravity == EastGravity or @gravity == WestGravity
+        y = y + height/2 - size.height/2
+      else
+        y = y - size.height/2
+      end
+      string.drawAtPoint_withAttributes([x,image.height-y-size.height], attributes)
+      self
+    end
+    def stroke(color)
+      log "stroke #{color}" 
+      @stroke_color = OSX::NSColor.colorWithName(color)
+      self
+    end
+    def fill(color)
+      log "fill #{color}" 
+      @fill_color = OSX::NSColor.colorWithName(color)
+      self
+    end
+    def rectangle(a,b,c,d)
+      log "rectangle #{a} #{b} #{c} #{d}" 
+      @fill_color.set
+      OSX::NSRectFill([a*@scalex,$height-d*@scalex,(c-a)*@scalex,(d-b)*@scaley])
+      self
+    end
+    def stroke_width(a)
+      log "stroke_width #{a}" 
+      @stroke_width = a
+      OSX::NSBezierPath.setDefaultLineWidth(a*@scalex)
+      self
+    end
+    def line(a,b,c,d)
+      log "line #{a} #{b} #{c} #{d}" 
+      @stroke_color.set
+      path = OSX::NSBezierPath.bezierPath
+      path.setLineDash_count_phase(@dasharray, @dashcount, 0) if @dasharray
+      path.moveToPoint([a*@scalex,$height-b*@scaley])
+      path.lineToPoint([c*@scalex,$height-d*@scaley])
+      path.stroke
+      self
+    end
+    def stroke_opacity(opacity)
+      log "stroke_opacity #{opacity}" 
+      @stroke_opacity = opacity
+      self
+    end
+    def stroke_color(color)
+      stroke(color)
+      self
+    end
+    def fill_opacity(opacity)
+      @fill_opacity = opacity
+      self
+    end
+    def stroke_dasharray(a, b)
+      log "stroke_dasharray #{a} #{b}" 
+      @dashcount = 2
+      @dasharray = [a,b].pack('f2')
+      self
+    end
+    def circle(cx,cy,px,py)
+      log "circle #{cx} #{cy} #{px} #{py}" 
+      r = Math::sqrt((cx-px)*(cx-px) + (cy-py)*(cy-py))
+      path = OSX::NSBezierPath.bezierPathWithOvalInRect(
+        [(cx-r)*@scalex,$height-(cy+r)*@scaley,2*r*@scalex,2*r*@scaley])
+      stroke_and_fill(path)
+      self
+    end
+    def ellipse(x, y, w, h, as, ae)
+      log "ellipse #{x} #{y} #{w} #{h} #{as} #{ae}" 
+      push
+      stroke_width(1)
+      @fill_color = @stroke_color   
+      path = OSX::NSBezierPath.bezierPath
+      center = [x*@scalex,$height-y*@scaley]
+      path.moveToPoint(center)
+      path.appendBezierPathWithArcWithCenter_radius_startAngle_endAngle(
+        center,2*w*@scalex,-ae,-as)
+      path.closePath
+      stroke_and_fill(path)
+      pop
+      self
+    end
+    def polyline(*args)
+      path = OSX::NSBezierPath.bezierPath
+      path.moveToPoint([args[0]*@scalex,$height-args[1]*@scaley])
+      i = 2
+      while(i < args.length) 
+        path.lineToPoint([args[i]*@scalex,$height-args[i+1]*@scaley])
+        i = i + 2
+      end
+      stroke_and_fill(path)
+      self
+    end
+    def polygon(*args)
+      path = OSX::NSBezierPath.bezierPath
+      path.moveToPoint([args[0]*@scalex,$height-args[1]*@scaley])
+      i = 2
+      while(i < args.length) 
+        path.lineToPoint([args[i]*@scalex,$height-args[i+1]*@scaley])
+        i = i + 2
+      end
+      path.closePath
+      stroke_and_fill(path)
+      self
+    end
+    def draw(a)
+      log "draw #{a}" 
+      self
+    end
+  end
+  class Image
+    attr_accessor :image, :width, :height   
+    def initialize(width, height, fill=nil)
+      log "Image.initialize #{width} #{height} #{fill}" 
+      @width = width
+      @height = height
+      @image = OSX::NSImage.alloc.initWithSize([width,height])
+      @image.lockFocus
+      if fill == nil 
+        OSX::NSColor.blackColor.set
+        OSX::NSRectFill([0,0,width,height])
+      elsif fill.class == Magick::GradientFill
+        gradient = fill.image
+        gradient.drawInRect_fromRect_operation_fraction([0,0,width,height], 
+          [0,0,gradient.size.width,gradient.size.height], OSX::NSCompositeCopy, 1.0)
+      else
+        fill.drawInRect_fromRect_operation_fraction([0,0,width,height], 
+          [0,0,fill.size.width,fill.size.height], OSX::NSCompositeCopy, 1.0)
+      end
+      $width = width
+      $height = height
+      self
+    end
+    def write(filename)
+      log "Image.write #{filename}" 
+      @image.unlockFocus
+      @image.writePNG(filename)
+      self
+    end
+    def self.read(filename)
+      log "Image.read #{filename}" 
+      image = OSX::NSImage.alloc.initWithContentsOfFile(filename)
+      [Image.new(800,600,image)]
+    end
+  end
+  class GradientFill
+    attr_accessor :image
+    def initialize(a,b,c,d,e,f)
+      log "GradientFill.initialize #{a} #{b} #{c} #{d} #{e} #{f}"     
+      # There's no direct gradient fill support in Cocoa, so fake it
+      resolution = 100  # increase this to reduce striping and increase run time...
+      @image = OSX::NSImage.alloc.initWithSize([1,resolution])
+      @image.lockFocus
+      bottomColor = OSX::NSColor.colorWithName(f)
+      topColor = OSX::NSColor.colorWithName(e)
+      resolution.times {|i|
+        bottomColor.blendedColorWithFraction_ofColor(i/(resolution - 1.0), topColor).set
+        OSX::NSRectFill([0,i,1,i+1])
+      }
+      self
+    end
+  end
+  class TypeMetric
+    attr_accessor :width
+    def initialize
+      @width = 50 
+    end
+  end
+  NormalWeight = 400
+  BoldWeight = 700
+  WestGravity = :west
+  EastGravity = :east
+  CenterGravity = :center
+  SouthGravity = :south
+  NorthGravity = :north
+  SouthWestGravity = :southwest
+  NorthWestGravity = :northwest
+  NorthEastGravity = :northeast
+  SouthEastGravity = :southeast
+end
+
+# this prevents a warning from AppKit
+app = OSX::NSApplication.sharedApplication

data/lib/gruff/bar.rb

@@ -16,11 +16,16 @@ class Gruff::Bar < Gruff::Base
 
     @d = @d.stroke_opacity 0.0
 
-    # setup the BarConversion Object
+    # Setup the BarConversion Object
     conversion = Gruff::BarConversion.new()
     conversion.graph_height = @graph_height
     conversion.graph_top = @graph_top
-    # set up the right mode [1,2,3] see BarConversion for further explains
+
+    # Labels will be centered over the left of the bar if
+    # there are more labels than columns.
+    center_labels_left = (@labels.keys.length > @column_count ? true : false)
+
+    # Set up the right mode [1,2,3] see BarConversion for further explanation
     if @minimum_value >= 0 then
       # all bars go from zero to positiv
       conversion.mode = 1
@@ -54,12 +59,18 @@ class Gruff::Bar < Gruff::Base
         @d = @d.rectangle(left_x, conv[0], right_x, conv[1])
 
         # Calculate center based on bar_width and current row
-        label_center = @graph_left + (@data.length * @bar_width * point_index) + (@data.length * @bar_width / 2.0)
-        draw_label(label_center, point_index)
+        label_center = @graph_left + 
+                      (@data.length * @bar_width * point_index) + 
+                      (@data.length * @bar_width / 2.0)
+        # Subtract half a bar width to center left if requested
+        draw_label(label_center - (center_labels_left ? @bar_width / 2.0 : 0.0), point_index)
       end
 
     end
 
+    # Draw the last label if requested
+    draw_label(@graph_right, @column_count) if center_labels_left
+
     @d.draw(@base_image)    
   end
 

data/lib/gruff/base.rb

@@ -14,20 +14,33 @@
 # and a cast of thousands.
 #
 
+require 'rubygems'
 require 'RMagick'
+require File.dirname(__FILE__) + '/deprecated'
 
 module Gruff
   
-  VERSION = '0.1.2'
+  VERSION = '0.2.3'
   
   class Base
   
     include Magick
+    include Deprecated
 
+    # Draw extra lines showing where the margins and text centers are
+    DEBUG = false
+
+    # Used for navigating the array of data to plot
     DATA_LABEL_INDEX = 0
     DATA_VALUES_INDEX = 1
     DATA_COLOR_INDEX = 2
 
+    # Blank space around the edges of the graph
+    TOP_MARGIN = BOTTOM_MARGIN = RIGHT_MARGIN = LEFT_MARGIN = 20.0
+    
+    # Space around text elements. Mostly used for vertical spacing
+    LEGEND_MARGIN = TITLE_MARGIN = LABEL_MARGIN = 10.0
+    
     # A hash of names for the individual columns, where the key is the array index for the column this label represents.
     #
     # Not all columns need to be named.
@@ -35,6 +48,17 @@ module Gruff
     # Example: 0 => 2005, 3 => 2006, 5 => 2007, 7 => 2008
     attr_accessor :labels
 
+    # A label for the bottom of the graph
+    attr_accessor :x_axis_label
+    
+    # A label for the left side of the graph
+    attr_accessor :y_axis_label
+
+    # attr_accessor :x_axis_increment
+    
+    # Manually set increment of the horizontal marking lines
+    attr_accessor :y_axis_increment
+
     # Get or set the list of colors that will be used to draw the bars or lines.
     attr_accessor :colors
 
@@ -64,6 +88,9 @@ module Gruff
     
     # The color of the auxiliary labels and lines
     attr_accessor :marker_color
+
+    # The number of horizontal lines shown for reference
+    attr_accessor :marker_count
     
     # The font size of the large title at the top of the graph
     attr_accessor :title_font_size
@@ -105,11 +132,13 @@ module Gruff
       @raw_columns = 800.0
       @raw_rows = 800.0 * (@rows/@columns)
       @column_count = 0
+      @marker_count = nil
       @maximum_value = @minimum_value = nil
       @has_data = false
       @data = Array.new
       @labels = Hash.new
       @labels_seen = Hash.new
+
       @scale = @columns / @raw_columns
 
       vera_font_path = File.expand_path('Vera.ttf', ENV['MAGICK_FONT_PATH'])
@@ -181,6 +210,11 @@ module Gruff
       end
     end
 
+    def font=(font_path)
+      @font = font_path
+      @d.font = @font
+    end
+
     # Add a color to the list of available colors for lines.
     #
     # Example: 
@@ -200,6 +234,14 @@ module Gruff
     
     # A color scheme similar to the popular presentation software.
     def theme_keynote
+      # defaults = {
+      #   :colors => ['black', 'white'],
+      #   :additional_line_colors => ['grey'],
+      #   :marker_color => 'white',
+      #   :background_colors => nil,
+      #   :background_image => nil
+      # }
+      
       reset_themes()
       # Colors
       @blue = '#6886B4'
@@ -284,7 +326,8 @@ module Gruff
     #  data("Bart S.", [95, 45, 78, 89, 88, 76], '#ffcc00')
     #
     def data(name, data_points=[], color=nil)
-      @data << [name, data_points, color || increment_color]
+      data_points = Array(data_points) # make sure it's an array
+      @data << [name, data_points, (color || increment_color)]
       # Set column count if this is larger than previous counts
       @column_count = (data_points.length > @column_count) ? data_points.length : @column_count
 
@@ -298,15 +341,12 @@ module Gruff
         end
 
         # TODO Doesn't work with stacked bar graphs
-        #Original: @maximum_value = larger_than_max?(data_point, index) ? max(data_point, index) : @maximum_value
+        # Original: @maximum_value = larger_than_max?(data_point, index) ? max(data_point, index) : @maximum_value
         @maximum_value = larger_than_max?(data_point) ? data_point : @maximum_value
-        if @maximum_value > 0
-          @has_data = true
-        end
+        @has_data = true if @maximum_value > 0
+        
         @minimum_value = less_than_min?(data_point) ? data_point : @minimum_value
-        if @minimum_value < 0
-     	  @has_data = true
-        end
+     	  @has_data = true if @minimum_value < 0
       end
     end
 
@@ -326,51 +366,17 @@ module Gruff
       end
     end
 
-    def scale_measurements
-      setup_graph_measurements
-    end
-    
-    def total_height
-      @rows + 10
-    end
-    
-    def graph_top
-      @graph_top * @scale
-    end
-    
-    def graph_height
-      @graph_height * @scale
-    end
-    
-    def graph_left 
-      @graph_left * @scale 
-    end
-    
-    def graph_width
-      @graph_width * @scale
-    end
-
-
 protected
 
-
-    def make_stacked
-      stacked_values = Array.new(@column_count, 0)
-      @data.each do |value_set|
-        value_set[1].each_with_index do |value, index|
-          stacked_values[index] += value
-        end
-        value_set[1] = stacked_values.dup
-      end
-    end
-
-
     # Overridden by subclasses to do the actual plotting of the graph.
     #
     # Subclasses should start by calling super() for this method.
     def draw
       make_stacked if @stacked
       setup_drawing()
+      
+      debug { @d.rectangle( LEFT_MARGIN, TOP_MARGIN, 
+                            @raw_columns - RIGHT_MARGIN, @raw_rows - BOTTOM_MARGIN) }
   
       # Subclasses will do some drawing here...
       #@d.draw(@base_image)
@@ -392,26 +398,26 @@ protected
       sort_norm_data() # Sort norm_data with avg largest values set first (for display)
       
       draw_legend()
-      setup_graph_height()
       draw_line_markers()
+      draw_axis_labels()
       draw_title
     end
 
     # Make copy of data with values scaled between 0-100
-    def normalize
-      if @norm_data.nil?
+    def normalize(force=false)
+      if @norm_data.nil? || force
         @norm_data = []
         return unless @has_data
-        @spread = @maximum_value.to_f - @minimum_value.to_f
-        @spread = 20.0 if @spread == 0.0 # Protect from divide by zero
-        min_val = @minimum_value.to_f
+                
+        calculate_spread
+        
         @data.each do |data_row|
           norm_data_points = []
           data_row[DATA_VALUES_INDEX].each do |data_point|
             if data_point.nil?
               norm_data_points << nil
             else
-              norm_data_points << ((data_point.to_f - min_val ) / @spread)
+              norm_data_points << ((data_point.to_f - @minimum_value.to_f ) / @spread)
             end
           end
           @norm_data << [data_row[DATA_LABEL_INDEX], norm_data_points, data_row[DATA_COLOR_INDEX]]
@@ -419,28 +425,80 @@ protected
       end
     end
 
-    def setup_graph_height
-      @graph_height = @graph_bottom - @graph_top
+    def calculate_spread
+      @spread = @maximum_value.to_f - @minimum_value.to_f
+      @spread = @spread > 0 ? @spread : 1
     end
 
     def setup_graph_measurements
-      # TODO Separate horizontal lines from line number labels so they can be shown or hidden independently
-      # TODO Get width of longest left-hand vertical text label and space left margin accordingly
-      unless @hide_line_markers
-        @graph_left = 130.0 # TODO Calculate based on string width of labels
-        @graph_right_margin = 80.0 # TODO see previous line
-        @graph_bottom_margin = 80.0
+      @marker_caps_height = calculate_caps_height(@marker_font_size)
+      @title_caps_height = calculate_caps_height(@title_font_size)
+      @legend_caps_height = calculate_caps_height(@legend_font_size)
+      
+      if @hide_line_markers
+        (@graph_left, 
+         @graph_right_margin, 
+         @graph_bottom_margin) = [LEFT_MARGIN, RIGHT_MARGIN, BOTTOM_MARGIN]
       else
-        @graph_left = @graph_right_margin = @graph_bottom_margin =  40
+        @graph_left =           LEFT_MARGIN + 
+                                calculate_width(@marker_font_size, label(@maximum_value.to_f)) + 
+                                LABEL_MARGIN * 2 +
+                                (@y_axis_label.nil? ? 0.0 : @marker_caps_height + LABEL_MARGIN * 2)
+        # Make space for half the width of the rightmost column label.
+        # Might be greater than the number of columns if between-style bar markers are used.
+        last_label = @labels.keys.sort.last.to_i
+        @graph_right_margin =   RIGHT_MARGIN +
+                                (last_label >= (@column_count-1) ? calculate_width(@marker_font_size, @labels[last_label])/2.0 : 0)
+        @graph_bottom_margin =  BOTTOM_MARGIN + 
+                                @marker_caps_height + LABEL_MARGIN
       end
 
       @graph_right = @raw_columns - @graph_right_margin
-
       @graph_width = @raw_columns - @graph_left - @graph_right_margin
 
-      @graph_top = 150.0
-      @graph_bottom = @raw_rows - @graph_bottom_margin
-      setup_graph_height()
+      # When @hide title, leave a TITLE_MARGIN space for aesthetics.
+      # Same with @hide_legend
+      @graph_top = TOP_MARGIN + 
+                    (@hide_title ? TITLE_MARGIN : @title_caps_height + TITLE_MARGIN * 2) +
+                    (@hide_legend ? LEGEND_MARGIN : @legend_caps_height + LEGEND_MARGIN * 2)
+
+      @graph_bottom = @raw_rows - @graph_bottom_margin -
+                      (@x_axis_label.nil? ? 0.0 : @marker_caps_height + LABEL_MARGIN)
+      
+      @graph_height = @graph_bottom - @graph_top
+    end
+
+    # Draw the optional labels for the x axis and y axis.
+    def draw_axis_labels
+      unless @x_axis_label.nil?
+        # X Axis
+        # Centered vertically and horizontally by setting the
+        # height to 1.0 and the width to the width of the graph.
+        x_axis_label_y_coordinate = @graph_bottom + LABEL_MARGIN * 2 + @marker_caps_height
+
+        # TODO Center between graph area
+        @d.fill = @marker_color
+        @d.font = @font if @font
+        @d.stroke = 'transparent'
+        @d.pointsize = scale_fontsize(@marker_font_size)
+        @d.gravity = NorthGravity
+        @d = @d.annotate_scaled( @base_image, 
+                          @raw_columns, 1.0, 
+                          0.0, x_axis_label_y_coordinate, 
+                          @x_axis_label, @scale)
+        debug { @d.line 0.0, x_axis_label_y_coordinate, @raw_columns, x_axis_label_y_coordinate }
+      end
+
+      unless @y_axis_label.nil?
+        # Y Axis, rotated vertically
+        @d.rotation = 90.0
+        @d.gravity = CenterGravity
+        @d = @d.annotate_scaled( @base_image, 
+                          1.0, @raw_rows,
+                          LEFT_MARGIN + @marker_caps_height / 2.0, 0.0, 
+                          @y_axis_label, @scale)
+        @d.rotation = -90.0
+      end
     end
 
     # Draws horizontal background lines and labels
@@ -449,20 +507,39 @@ protected
             
       # Draw horizontal line markers and annotate with numbers
       @d = @d.stroke(@marker_color)
-      @d = @d.stroke_width 1
-      number_of_lines = 4
-
-      # TODO Round maximum marker value to a round number like 100, 0.1, 0.5, etc.
-      spread = @maximum_value.to_f - @minimum_value.to_f
-      spread = spread > 0 ? spread : 1
-      increment = (spread > 0) ? significant(spread / number_of_lines) : 1
-      inc_graph = @graph_height.to_f / (spread / increment)
+      @d = @d.stroke_width 1 
+
+      if @y_axis_increment.nil?
+        # Try to use a number of horizontal lines that will come out even.
+        #
+        # TODO Do the same for larger numbers...100, 75, 50, 25
+        if @marker_count.nil?
+          (3..7).each do |lines|
+            if @spread % lines == 0.0
+              @marker_count = lines
+              break
+            end
+          end
+          @marker_count ||= 4
+        end
+        @increment = (@spread > 0) ? significant(@spread / @marker_count) : 1
+      else
+        # TODO Make this work for negative values
+        @maximum_value = [@maximum_value.ceil, @y_axis_increment].max
+        @minimum_value = @minimum_value.floor
+        calculate_spread
+        normalize(true)
+        
+        @marker_count = (@spread / @y_axis_increment).to_i
+        @increment = @y_axis_increment
+      end
+      @increment_scaled = @graph_height.to_f / (@spread / @increment)
 
-      (0..number_of_lines).each do |index|
-        y = @graph_top + @graph_height - index.to_f * inc_graph
+      (0..@marker_count).each do |index|
+        y = @graph_top + @graph_height - index.to_f * @increment_scaled
         @d = @d.line(@graph_left, y, @graph_right, y)
 
-        marker_label = index * increment + @minimum_value.to_f
+        marker_label = index * @increment + @minimum_value.to_f
 
         @d.fill = @marker_color
         @d.font = @font if @font
@@ -470,16 +547,19 @@ protected
         @d.pointsize = scale_fontsize(@marker_font_size)
         @d.gravity = EastGravity
         
+        # Vertically center with 1.0 for the height
         @d = @d.annotate_scaled( @base_image, 
-                          100, 20,
-                          -10, y - (@marker_font_size/2.0), 
-                          marker_label.to_s, @scale)
+                          @graph_left - LABEL_MARGIN, 1.0,
+                          0.0, y,
+                          label(marker_label), @scale)
       end
+      
+      # Submitted by a contibutor...the utility escapes me
       i = 0
       @additional_line_values.each do |value|
-        inc_graph = @graph_height.to_f / (@maximum_value.to_f / value)
+        @increment_scaled = @graph_height.to_f / (@maximum_value.to_f / value)
         
-        y = @graph_top + @graph_height - inc_graph
+        y = @graph_top + @graph_height - @increment_scaled
         
         @d = @d.stroke(@additional_line_colors[i])
         @d = @d.line(@graph_left, y, @graph_right, y)
@@ -498,13 +578,15 @@ protected
       end
     end
 
-    # Draws a legend with the names of the datasets matched to the colors used to draw them.
+    # Draws a legend with the names of the datasets 
+    # matched to the colors used to draw them.
     def draw_legend
       return if @hide_legend
 
       @legend_labels = @data.collect {|item| item[DATA_LABEL_INDEX] }
 
       legend_square_width = 20 # small square with color of this item
+      legend_square_margin = 4
 
       # May fix legend drawing problem at small sizes
       @d.font = @font if @font
@@ -512,12 +594,22 @@ protected
 
       metrics = @d.get_type_metrics(@base_image, @legend_labels.join(''))
       legend_text_width = metrics.width
-      legend_width = legend_text_width + (@legend_labels.length * legend_square_width * 2.7)
+      legend_width = legend_text_width + 
+                    (@legend_labels.length * legend_square_width * 2.7)
       legend_left = (@raw_columns - legend_width) / 2
       legend_increment = legend_width / @legend_labels.length.to_f
 
       current_x_offset = legend_left
+      current_y_offset =  @hide_title ? 
+                          TOP_MARGIN + LEGEND_MARGIN : 
+                          TOP_MARGIN + 
+                          TITLE_MARGIN + @title_caps_height +
+                          LEGEND_MARGIN
+
+      debug { @d.line 0.0, current_y_offset, @raw_columns, current_y_offset }
+                                                    
       @legend_labels.each_with_index do |legend_label, index|        
+
         # Draw label
         @d.fill = @marker_color
         @d.font = @font if @font
@@ -526,16 +618,17 @@ protected
         @d.font_weight = NormalWeight
         @d.gravity = WestGravity
         @d = @d.annotate_scaled( @base_image, 
-                          @raw_columns, 24,
-                          current_x_offset + (legend_square_width * 1.7), 70, 
+                          @raw_columns, 1.0,
+                          current_x_offset + (legend_square_width * 1.7), current_y_offset, 
                           legend_label.to_s, @scale)
         
         # Now draw box with color of this dataset
-        legend_box_y_offset = 2 # Move box down slightly to center
         @d = @d.stroke 'transparent'
         @d = @d.fill @data[index][DATA_COLOR_INDEX]
-        @d = @d.rectangle(current_x_offset, 70 + legend_box_y_offset, 
-                          current_x_offset + legend_square_width, 70 + legend_square_width + legend_box_y_offset)
+        @d = @d.rectangle(current_x_offset, 
+                          current_y_offset - legend_square_width / 2.0, 
+                          current_x_offset + legend_square_width, 
+                          current_y_offset + legend_square_width / 2.0)
 
         @d.pointsize = @legend_font_size
         metrics = @d.get_type_metrics(@base_image, legend_label.to_s)
@@ -553,30 +646,36 @@ protected
       @d.stroke = 'transparent'
       @d.pointsize = scale_fontsize(@title_font_size)
       @d.font_weight = BoldWeight
-      @d.gravity = CenterGravity
+      @d.gravity = NorthGravity
       @d = @d.annotate_scaled( @base_image, 
-                        @raw_columns, 50,
-                        0, 10, 
+                        @raw_columns, 1.0,
+                        0, TOP_MARGIN, 
                         @title, @scale)
     end
 
     ##
     # Draws column labels below graph, centered over x_offset
+    #
+    # TODO Allow WestGravity as an option
+    
     def draw_label(x_offset, index)
       return if @hide_line_markers
 
       if !@labels[index].nil? && @labels_seen[index].nil?
+        y_offset = @graph_bottom + LABEL_MARGIN
+
         @d.fill = @marker_color
         @d.font = @font if @font
         @d.stroke = 'transparent'
         @d.font_weight = NormalWeight
         @d.pointsize = scale_fontsize(@marker_font_size)
-        @d.gravity = CenterGravity
+        @d.gravity = NorthGravity
         @d = @d.annotate_scaled(@base_image,
-                                1, 1,
-                                x_offset, @raw_rows - (@graph_bottom_margin - 30),
+                                1.0, 1.0,
+                                x_offset, y_offset,
                                 @labels[index], @scale)
         @labels_seen[index] = 1
+        debug { @d.line 0.0, y_offset, @raw_columns, y_offset }
       end
     end
 
@@ -621,7 +720,6 @@ protected
       
       @d = Draw.new
       # Scale down from 800x600 used to calculate drawing.
-      # NOTE: Font annotation is now affected and has to be done manually.
       @d = @d.scale(@scale, @scale)
     end
 
@@ -629,9 +727,10 @@ protected
       value * @scale
     end
     
+    # Return a comparable fontsize for the current graph.
     def scale_fontsize(value)
       new_fontsize = value * @scale
-      #return 10 if new_fontsize < 10
+      # return new_fontsize < 10.0 ? 10.0 : new_fontsize
       return new_fontsize
     end
 
@@ -648,10 +747,14 @@ protected
       data_point < @minimum_value
     end
 
+    ##
+    # Overridden by subclasses that need it.
     def max(data_point, index)
       data_point
     end
 
+    ##
+    # Overridden by subclasses that need it.
 	  def min(data_point, index)
       data_point
     end
@@ -706,9 +809,30 @@ protected
       @minimum_value = 0
     end
 
+    def make_stacked
+      stacked_values = Array.new(@column_count, 0)
+      @data.each do |value_set|
+        value_set[1].each_with_index do |value, index|
+          stacked_values[index] += value
+        end
+        value_set[1] = stacked_values.dup
+      end
+    end
 
 private
     
+    # Takes a block and draws it if DEBUG is true.
+    #
+    #   debug { @d.rectangle x1, y1, x2, y2 }
+    #
+    def debug
+      if DEBUG
+        @d = @d.fill 'transparent'
+        @d = @d.stroke 'turquoise'
+        @d = yield
+      end
+    end
+    
     def increment_color
       if @color_index == 0
         @color_index += 1
@@ -726,14 +850,51 @@ private
       end
     end
 
-  end
+    def label(value)      
+      if (@spread.to_f % @marker_count.to_f == 0) || !@y_axis_increment.nil?
+        return value.to_i.to_s
+      end
+      
+      if @spread > 10.0
+        sprintf("%0i", value)
+      elsif @spread >= 3.0
+        sprintf("%0.2f", value)
+      else
+        value.to_s
+      end
+    end
+
+    ##
+    # Returns the height of the capital letter 'X' for the current font and size.
+    #
+    # Not scaled since it deals with dimensions that the regular 
+    # scaling will handle.
+    
+    def calculate_caps_height(font_size)
+      @d.pointsize = font_size
+      @d.get_type_metrics(@base_image, 'X').height
+    end
+
+    ##
+    # Returns the width of a string at this pointsize.
+    #
+    # Not scaled since it deals with dimensions that the regular 
+    # scaling will handle.
+    
+    def calculate_width(font_size, text)
+      @d.pointsize = font_size
+      @d.get_type_metrics(@base_image, text.to_s).width
+    end
+
+  end # Gruff::Base
   
   class ColorlistExhaustedException < StandardError; end
       
-end
+end # Gruff
 
 
 module Magick
+  
   class Draw
     
     # Additional method since Draw.scale doesn't affect annotations.
@@ -748,4 +909,6 @@ module Magick
     end
     
   end
-end
+  
+end # Magick
+