sskirby-prawn-layout 0.1.0 → 0.1.1

data/examples/table/fancy_table.rb

@@ -0,0 +1,67 @@
+# encoding: utf-8
+#
+# Demonstrates various table and cell features.  
+#
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', '..', 'lib'))
+
+require "rubygems"
+require "prawn"
+require "prawn/layout"
+   
+headers, body = nil, nil  
+
+dir = File.expand_path(File.dirname(__FILE__))
+     
+ruby_18 do        
+  require "fastercsv" 
+  headers, *body = FasterCSV.read("#{dir}/addressbook.csv")   
+end
+
+ruby_19 do            
+  require "csv"
+  headers, *body = CSV.read("#{dir}/addressbook.csv", 
+                      :encoding => "utf-8")
+end
+                                                                                  
+Prawn::Document.generate("fancy_table.pdf", :page_layout => :landscape) do
+  
+  #font "#{Prawn::BASEDIR}/data/fonts/DejaVuSans.ttf"
+
+  mask(:y) { table body, :headers      => headers, 
+                         :align        => :center,
+                         :border_style => :grid     }
+
+  table [["This is",   "A Test"    ],
+         [  Prawn::Table::Cell.new( :text => "Of tables",
+                                       :background_color => "ffccff" ),
+          "Drawn Side"], ["By side",   "and stuff" ]], 
+    :position         => 600, 
+    :headers          => ["Col A", "Col B"],
+    :border_width     => 1,
+    :vertical_padding => 5,
+    :horizontal_padding => 3,
+    :font_size        => 10,
+    :row_colors       => :pdf_writer,
+    :column_widths => { 1 => 50 }
+
+  move_down 150
+
+  table [%w[1 2 3],%w[4 5 6],%w[7 8 9]], 
+    :position => :center,
+    :border_width   => 0,
+    :font_size => 40
+
+  cell [500,300],
+    :text => "This free flowing textbox shows how you can use Prawn's "+
+      "cells outside of a table with ease.  Think of a 'cell' as " +
+      "simply a limited purpose bounding box that is meant for laying " +
+      "out blocks of text and optionally placing a border around it",
+    :width => 225, :padding => 10, :border_width => 2
+
+  font_size 24
+
+  cell [50,75], 
+    :text => "This document demonstrates a number of Prawn's table features",
+    :border_style => :no_top, # :all, :no_bottom, :sides
+    :horizontal_padding => 5
+end

data/examples/table/table.rb

@@ -0,0 +1,54 @@
+# encoding: utf-8
+#
+# Generates a couple simple tables, including some UTF-8 text cells.
+# Although this does not show all of the options available to table, the most
+# common are used here.  See fancy_table.rb for a more comprehensive example.
+#
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', '..', 'lib'))
+
+require "rubygems"
+require "prawn"
+require "prawn/layout"
+ 
+Prawn::Document.generate("table.pdf") do 
+  font "#{Prawn::BASEDIR}/data/fonts/DejaVuSans.ttf"
+  table [["ὕαλον ϕαγεῖν",    "baaar",    "1" ],
+         ["This is","a sample",          "2" ],
+         ["Table",  "dont\ncha\nknow?",  "3" ],
+         [ "It",    "Rules",             "4" ],     
+         [ "It",    "Rules",             "4" ],     
+         [ "It",    "Rules",             "4123231" ],     
+         [ "It",    "Rules",             "22.5" ],     
+         [ "It",    "Rules",             "4" ],     
+         [ "It",    "Rules",             "4" ],     
+         [ "It",    "Rules",             "4" ],     
+         [ "It",    "Rules",             "4" ],     
+         [ "It",    "Rules",             "4" ],     
+         [ "It",    "Rules\nwith an iron fist", "x" ],     
+         [ "It",    "Rules",             "4" ],     
+         [ "It",    "Rules",             "4" ],     
+         [ "It",    "Rules",             "4" ],     
+         [ "It",    "Rules",             "4" ],     
+         [ "It",    "Rules",             "4" ],     
+         [ "It",    "Rules",             "4" ],     
+         [ "It",    "Rules",             "4" ],     
+         [ "It",    "Rules",             "4" ],     
+         [ "It",    "Rules",             "4" ]],     
+
+    :font_size  => 24, 
+    :horizontal_padding => 10,
+    :vertical_padding   => 3,
+    :border_width       => 2,
+    :position           => :center,
+    :headers            => ["Column A","Column B","#"],
+    :align              => {1 => :center},
+    :align_headers      => :center
+                            
+  text "This should appear in the original font size, just below the table"     
+  move_down 10
+  
+  table [[ "Wide", "columns", "streeetch"], 
+         ["are","mighty fine", "streeeeeeeech"]],
+    :column_widths => { 0 => 200, 1 => 200 }, :position => 5
+
+end

data/examples/table/table_alignment.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+#
+# Demonstrates the many controls over alignment and positioning in Prawn
+# tables.
+#
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', '..', 'lib'))
+
+require "rubygems"
+require "prawn"
+require "prawn/layout"
+
+Prawn::Document.generate "table_header_align.pdf" do
+  table [ ['01/01/2008', 'John Doe', '4.2', '125.00', '525.00'],
+	  ['01/12/2008', 'Jane Doe', '3.2', '75.50', '241.60'] ] * 20,
+  :position => :center,
+  :headers => ['Date', 'Employee', 'Hours', 'Rate', 'Total'],
+  :column_widths => { 0 => 75, 1 => 100, 2 => 50, 3 => 50, 4 => 50},
+  :border_style => :grid,
+  :align => { 0 => :right, 1 => :left, 2 => :right, 3 => :right, 4 => :right },
+  :align_headers => { 0 => :center, 2 => :left, 3 => :left, 4 => :right }
+end

data/examples/table/table_border_color.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+#
+# Demonstrates how to set the table border color with the :border_color
+# attribute.
+#
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', '..', 'lib'))
+
+require "rubygems"
+require "prawn"
+require "prawn/layout"
+
+Prawn::Document.generate "table_border_color.pdf" do
+  table [ ['01/01/2008', 'John Doe', '4.2', '125.00', '525.00'], 
+          ['01/12/2008', 'Jane Doe', '3.2', '75.50', '241.60'] ] * 20,
+  :position => :center,
+  :headers => ['Date', 'Employee', 'Hours', 'Rate', 'Total'],
+  :column_widths => { 0 => 75, 1 => 100, 2 => 50, 3 => 50, 4 => 50},
+  :border_style => :grid,
+  :border_color => "ff0000"
+end

data/examples/table/table_colspan.rb

@@ -0,0 +1,22 @@
+# encoding: utf-8
+#
+# Demonstrates the use of the :col_span option when using Document#table
+#
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', '..', 'lib'))
+
+require "rubygems"
+require "prawn"
+require "prawn/layout"
+
+Prawn::Document.generate "table_colspan.pdf" do
+  data = [ ['01/01/2008', 'John Doe', '4.2', '125.00', '525.00'], 
+           ['01/12/2008', 'Jane Doe', '3.2', '75.50', '241.60'] ] * 5
+  
+  data << [{:text => 'Total', :colspan => 2}, '37.0', '1002.5', '3833']
+  
+  table data,
+  :position => :center,
+  :headers => ['Date', 'Employee', 'Hours', 'Rate', 'Total'],
+  :column_widths => { 0 => 75, 1 => 100, 2 => 50, 3 => 50, 4 => 50},
+  :border_style => :grid
+end

data/examples/table/table_header_color.rb

@@ -0,0 +1,22 @@
+# encoding: utf-8
+#
+# Demonstrates explicitly setting the :header_color rather than inferring
+# it from :row_colors in Document#table
+#
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', '..', 'lib'))
+
+require "rubygems"
+require "prawn"
+require "prawn/layout"
+
+Prawn::Document.generate "table_header_color.pdf" do
+  table [ ['01/01/2008', 'John Doe', '4.2', '125.00', '525.00'], 
+          ['01/12/2008', 'Jane Doe', '3.2', '75.50', '241.60'] ] * 20,
+  :position => :center,
+  :headers => ['Date', 'Employee', 'Hours', 'Rate', 'Total'],
+  :column_widths => { 0 => 75, 1 => 100, 2 => 50, 3 => 50, 4 => 50},
+  :border_style => :grid,
+  :header_color => 'f07878',
+  :header_text_color  => "990000",
+  :row_colors => ["FFCCFF","CCFFCC"]
+end

data/examples/table/table_header_underline.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+#
+# Demonstrates the :underline_header border style for Document#table.
+#
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', '..', 'lib'))
+
+require "rubygems"
+require "prawn"
+require "prawn/layout"
+
+Prawn::Document.generate "table_header_underline.pdf" do
+  table [ ['01/01/2008', 'John Doe', '4.2', '125.00', '525.00'], 
+          ['01/12/2008', 'Jane Doe', '3.2', '75.50', '241.60'] ] * 5,
+  :position => :center,
+  :headers => ['Date', 'Employee', 'Hours', 'Rate', 'Total'],
+  :column_widths => { 0 => 75, 1 => 100, 2 => 50, 3 => 50, 4 => 50},
+  :border_style => :underline_header
+end

data/examples/table/table_widths.rb

@@ -0,0 +1,64 @@
+# encoding: utf-8
+#
+# Generates a couple simple tables, including some UTF-8 text cells.
+# Although this does not show all of the options available to table, the most
+# common are used here.  See fancy_table.rb for a more comprehensive example.
+#
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', '..', 'lib'))
+
+require "rubygems"
+require "prawn"
+require "prawn/layout"
+
+Prawn::Document.generate("table_widths.pdf") do 
+
+  data = [
+    %w(one two three four),
+    %w(five six seven eight),
+    %w(nine ten eleven twelve),
+    %w(thirteen fourteen fifteen sixteen),
+    %w(seventeen eighteen nineteen twenty)
+  ]
+  headers = ["Column A","Column B","Column C", "Column D"]
+
+  text "A table with a specified width of the document width (within margins)"
+  move_down 10
+
+  table data,    
+    :position   => :center,
+    :headers    => headers,
+    :width      => margin_box.width
+
+
+  move_down 20
+  text "A table with a specified width of the document width (within margins) and two fixed width columns"
+  move_down 10
+
+  table data,    
+    :position      => :center,
+    :headers       => headers,
+    :width         => margin_box.width,
+    :column_widths => {0 => 70, 1 => 70}
+
+
+  move_down 20
+  text "A table with a specified width of 300"
+  move_down 10
+
+  table data,    
+    :position   => :center,
+    :headers    => headers,
+    :width      => 300
+
+
+  move_down 20
+  text "A table with too much data is automatically limited to the document width"
+  move_down 10
+
+  data << ['some text', 'A long piece of text that will make this cell too wide for the page', 'some more text', 'And more text']
+
+  table data,    
+    :position   => :center,
+    :headers    => headers
+
+end

data/lib/prawn/layout.rb

@@ -0,0 +1,20 @@
+require "prawn/table"
+require "prawn/layout/page"
+
+module Prawn
+  
+ module Errors
+   
+   # This error is raised when table data is malformed
+   #
+   InvalidTableData = Class.new(StandardError)
+
+   # This error is raised when an empty or nil table is rendered
+   #
+   EmptyTable = Class.new(StandardError)
+ end
+
+ module Layout
+
+ end
+end

data/lib/prawn/layout/page.rb

@@ -0,0 +1,116 @@
+# encoding: utf-8
+
+# layout/page.rb : Provides helpers for page layout
+#
+# Copyright January 2009, Gregory Brown. All Rights Reserved.
+#
+# This is free software. Please see the LICENSE and COPYING files for details.
+
+module Prawn
+  class Document
+    # A LazyBoundingBox is simply a BoundingBox with an action tied to it to be 
+    # executed later.  The lazy_bounding_box method takes the same arguments as
+    # bounding_box, but returns a LazyBoundingBox object instead of executing
+    # the code block directly.
+    #
+    # You can then call LazyBoundingBox#draw at any time (or multiple times if 
+    # you wish), and the contents of the block will then be run. This can be
+    # useful for assembling repeating page elements or reusable components.
+    #
+    #  file = "lazy_bounding_boxes.pdf"
+    #  Prawn::Document.generate(file, :skip_page_creation => true) do                    
+    #    point = [bounds.right-50, bounds.bottom + 25]
+    #    page_counter = lazy_bounding_box(point, :width => 50) do   
+    #      text "Page: #{page_count}"
+    #    end 
+    #
+    #    10.times do         
+    #     start_new_page
+    #      text "Some text"  
+    #      page_counter.draw
+    #    end
+    #  end
+    #
+    def lazy_bounding_box(*args,&block)
+      translate!(args[0])  
+      box = LazyBoundingBox.new(self,*args)
+      box.action(&block)
+      return box 
+    end
+    
+    # A bounding box with the same dimensions of its parents, minus a margin
+    # on all sides
+    #
+    def padded_box(margin, &block)
+      bounding_box [bounds.left + margin, bounds.top - margin],
+        :width  => bounds.width - (margin * 2), 
+        :height => bounds.height - (margin * 2), &block 
+    end
+       
+    # A header is a LazyBoundingBox drawn relative to the margins that can be
+    # repeated on every page of the document.
+    #
+    # Unless <tt>:width</tt> or <tt>:height</tt> are specified, the margin_box
+    # width and height are used.   
+    #
+    #   header margin_box.top_left do 
+    #    text "Here's My Fancy Header", :size => 25, :align => :center   
+    #    stroke_horizontal_rule
+    #  end
+    #
+    def header(top_left,options={},&block)   
+      @header = repeating_page_element(top_left,options,&block)
+    end
+        
+    # A footer is a LazyBoundingBox drawn relative to the margins that can be
+    # repeated on every page of the document.
+    #
+    # Unless <tt>:width</tt> or <tt>:height</tt> are specified, the margin_box
+    # width and height are used.
+    #
+    #   footer [margin_box.left, margin_box.bottom + 25] do
+    #     stroke_horizontal_rule
+    #     text "And here's a sexy footer", :size => 16
+    #   end    
+    #
+    def footer(top_left,options={},&block)       
+      @footer = repeating_page_element(top_left,options,&block)
+    end
+
+    private
+
+    def repeating_page_element(top_left,options={},&block)   
+      r = LazyBoundingBox.new(self, translate(top_left),
+        :width  => options[:width]  || margin_box.width, 
+        :height => options[:height] || margin_box.height )
+      r.action(&block)
+      return r
+    end  
+
+    class LazyBoundingBox < BoundingBox
+       
+      # Defines the block to be executed by LazyBoundingBox#draw. 
+      # Usually, this will be used via a higher level interface.  
+      # See the documentation for Document#lazy_bounding_box, Document#header,
+      # and Document#footer
+      #
+      def action(&block)
+        @action = block
+      end
+      
+      # Sets Document#bounds to use the LazyBoundingBox for its bounds,
+      # runs the block specified by LazyBoundingBox#action,
+      # and then restores the original bounds of the document.
+      #
+      def draw
+        @parent.mask(:y) do  
+          parent_box = @parent.bounds  
+          @parent.bounds = self    
+          @parent.y = absolute_top
+          @action.call   
+          @parent.bounds = parent_box
+        end
+      end
+    end
+  end
+end

data/lib/prawn/table.rb

@@ -0,0 +1,373 @@
+# encoding: utf-8
+#
+# table.rb : Simple table drawing functionality
+#
+# Copyright June 2008, Gregory Brown.  All Rights Reserved.
+#
+# This is free software. Please see the LICENSE and COPYING files for details.
+
+require "prawn/table/cell"
+
+module Prawn
+  class Document    
+    
+    # Builds and renders a Document::Table object from raw data.
+    # For details on the options that can be passed, see
+    # Document::Table.new
+    #
+    #   data = [["Gregory","Brown"],["James","Healy"],["Jia","Wu"]]
+    #
+    #   Prawn::Document.generate("table.pdf") do
+    #     
+    #     # Default table, without headers
+    #     table(data)
+    #
+    #     # Default table with headers
+    #     table data, :headers => ["First Name", "Last Name"]
+    #
+    #     # Very close to PDF::Writer's default SimpleTable output
+    #     table data, :headers            => ["First Name", "Last Name"],
+    #                 :font_size          => 10,
+    #                 :vertical_padding   => 2,
+    #                 :horizontal_padding => 5,
+    #                 :position           => :center,
+    #                 :row_colors         => :pdf_writer,
+    #
+    #     # Grid border style with explicit column widths.
+    #     table data, :border_style => :grid,
+    #                 :column_widths       => { 0 => 100, 1 => 150 }
+    #
+    #   end
+    #
+    #   Will raise <tt>Prawn::Errors::EmptyTable</tt> given 
+    #   a nil or empty <tt>data</tt> paramater.
+    #
+    def table(data, options={})           
+      if data.nil? || data.empty?
+        raise Prawn::Errors::EmptyTable,
+          "data must be a non-empty, non-nil, two dimensional array of Prawn::Cells or strings"
+      end
+      Prawn::Table.new(data,self,options).draw
+    end
+  end
+
+
+  # This class implements simple PDF table generation.
+  # 
+  # Prawn tables have the following features:
+  #
+  #   * Can be generated with or without headers
+  #   * Can tweak horizontal and vertical padding of text
+  #   * Minimal styling support (borders / row background colors)
+  #   * Can be positioned by bounding boxes (left/center aligned) or an
+  #     absolute x position
+  #   * Automated page-breaking as needed
+  #   * Column widths can be calculated automatically or defined explictly on a 
+  #     column by column basis
+  #   * Text alignment can be set for the whole table or by column
+  #
+  # The current implementation is a bit barebones, but covers most of the
+  # basic needs for PDF table generation.  If you have feature requests,
+  # please share them at: http://groups.google.com/group/prawn-ruby
+  #
+  # Tables will be revisited before the end of the Ruby Mendicant project and
+  # the most commonly needed functionality will likely be added.
+  #
+  class Table  
+    
+    include Prawn::Configurable
+
+    attr_reader :column_widths # :nodoc: 
+    
+    NUMBER_PATTERN = /^-?(?:0|[1-9]\d*)(?:\.\d+(?:[eE][+-]?\d+)?)?$/ #:nodoc: 
+
+    # Creates a new Document::Table object. This is generally called 
+    # indirectly through Document#table but can also be used explictly.
+    #
+    # The <tt>data</tt> argument is a two dimensional array of strings,
+    # organized by row, e.g. [["r1-col1","r1-col2"],["r2-col2","r2-col2"]].
+    # As with all Prawn text drawing operations, strings must be UTF-8 encoded.
+    #
+    # The following options are available for customizing your tables, with
+    # defaults shown in [] at the end of each description.
+    #
+    # <tt>:headers</tt>:: An array of table headers, either strings or Cells. [Empty]
+    # <tt>:align_headers</tt>:: Alignment of header text.  Specify for entire header (<tt>:left</tt>) or by column (<tt>{ 0 => :right, 1 => :left}</tt>). If omitted, the header alignment is the same as the column alignment.
+    # <tt>:header_text_color</tt>:: Sets the text color of the headers
+    # <tt>:header_color</tt>:: Manually sets the header color
+    # <tt>:font_size</tt>:: The font size for the text cells . [12]
+    # <tt>:horizontal_padding</tt>:: The horizontal cell padding in PDF points [5]
+    # <tt>:vertical_padding</tt>:: The vertical cell padding in PDF points [5]
+    # <tt>:padding</tt>:: Horizontal and vertical cell padding (overrides both)
+    # <tt>:border_width</tt>:: With of border lines in PDF points [1]
+    # <tt>:border_style</tt>:: If set to :grid, fills in all borders. If set to :underline_header, underline header only. Otherwise, borders are drawn on columns only, not rows
+    # <tt>:border_color</tt>:: Sets the color of the borders.
+    # <tt>:position</tt>:: One of <tt>:left</tt>, <tt>:center</tt> or <tt>n</tt>, where <tt>n</tt> is an x-offset from the left edge of the current bounding box
+    # <tt>:width:</tt> A set width for the table, defaults to the sum of all column widths
+    # <tt>:column_widths:</tt> A hash of indices and widths in PDF points.  E.g. <tt>{ 0 => 50, 1 => 100 }</tt>
+    # <tt>:row_colors</tt>:: An array of row background colors which are used cyclicly.   
+    # <tt>:align</tt>:: Alignment of text in columns, for entire table (<tt>:center</tt>) or by column (<tt>{ 0 => :left, 1 => :center}</tt>)
+    # <tt>:minimum_rows</tt>:: The minimum rows to display on a page, including header.
+    #
+    # Row colors are specified as html encoded values, e.g.
+    # ["ffffff","aaaaaa","ccaaff"].  You can also specify 
+    # <tt>:row_colors => :pdf_writer</tt> if you wish to use the default color
+    # scheme from the PDF::Writer library.
+    #
+    # See Document#table for typical usage, as directly using this class is
+    # not recommended unless you know why you want to do it.
+    #
+    def initialize(data, document, options={})     
+      unless data.all? { |e| Array === e }
+        raise Prawn::Errors::InvalidTableData,
+          "data must be a two dimensional array of Prawn::Cells or strings"
+      end
+      
+      @data     = data        
+      @document = document
+      
+      Prawn.verify_options [:font_size,:border_style, :border_width,
+       :position, :headers, :row_colors, :align, :align_headers, 
+       :header_text_color, :border_color, :horizontal_padding, 
+       :vertical_padding, :padding, :column_widths, :width, :header_color ], 
+       options     
+                                          
+      configuration.update(options)  
+
+      if padding = options[:padding]
+        C(:horizontal_padding => padding, :vertical_padding => padding) 
+      end
+       
+      if options[:row_colors] == :pdf_writer 
+        C(:row_colors => ["ffffff","cccccc"])  
+      end
+      
+      if options[:row_colors]
+        C(:original_row_colors => C(:row_colors)) 
+      end
+
+      calculate_column_widths(options[:column_widths], options[:width])
+    end                                        
+    
+    attr_reader :column_widths #:nodoc:
+    
+    # Width of the table in PDF points
+    #
+    def width
+       @column_widths.inject(0) { |s,r| s + r }
+    end
+    
+    # Draws the table onto the PDF document
+    #
+    def draw  
+      @parent_bounds = @document.bounds  
+      case C(:position) 
+      when :center
+        x = (@document.bounds.width - width) / 2.0
+        dy = @document.bounds.absolute_top - @document.y
+        @document.bounding_box [x, @parent_bounds.top], :width => width do 
+          @document.move_down(dy)
+          generate_table
+        end
+      when Numeric     
+        x, y = C(:position), @document.y - @document.bounds.absolute_bottom
+        @document.bounding_box([x,y], :width => width) { generate_table }
+      else
+        generate_table
+      end
+    end
+
+    private
+    
+    def default_configuration     
+      { :font_size           => 12, 
+        :border_width        => 1, 
+        :position            => :left,
+        :horizontal_padding  => 5,
+        :vertical_padding    => 5 } 
+    end
+
+    def calculate_column_widths(manual_widths=nil, width=nil)
+      @column_widths = [0] * @data[0].inject(0){ |acc, e| 
+        acc += (e.is_a?(Hash) && e.has_key?(:colspan)) ? e[:colspan] : 1 }
+      renderable_data.each do |row|
+        row.each_with_index do |cell,i|
+          length = cell.to_s.lines.map { |e| 
+            @document.width_of(e, :size => C(:font_size)) }.max.to_f +
+              2*C(:horizontal_padding)
+          @column_widths[i] = length.ceil if length > @column_widths[i]
+        end
+      end  
+
+      manual_width = 0
+      manual_widths.each { |k,v| 
+        @column_widths[k] = v; manual_width += v } if manual_widths           
+
+      #Ensures that the maximum width of the document is not exceeded
+      #Takes into consideration the manual widths specified (With full manual 
+      # widths specified, the width can exceed the document width as manual 
+      # widths are taken as gospel)
+      max_width = width || @document.margin_box.width
+      calculated_width = @column_widths.inject {|sum,e| sum += e }
+
+      if calculated_width > max_width
+        shrink_by = (max_width - manual_width).to_f / 
+          (calculated_width - manual_width)
+        @column_widths.each_with_index { |c,i| 
+          @column_widths[i] = c * shrink_by if manual_widths.nil? || 
+            manual_widths[i].nil? 
+        }
+      elsif width && calculated_width < width
+        grow_by = (width - manual_width).to_f / 
+          (calculated_width - manual_width)
+        @column_widths.each_with_index { |c,i| 
+          @column_widths[i] = c * grow_by if manual_widths.nil? || 
+            manual_widths[i].nil? 
+        }
+      end
+    end
+
+    def renderable_data
+      C(:headers) ? [C(:headers)] + @data : @data
+    end
+
+    def generate_table    
+      page_contents = []
+      y_pos = @document.y 
+
+      @document.font_size C(:font_size) do
+        renderable_data.each_with_index do |row,index|
+          c = Prawn::Table::CellBlock.new(@document)
+          
+          col_index = 0
+          row.each do |e|
+            case C(:align)
+            when Hash
+              align            = C(:align)[col_index]
+            else
+              align            = C(:align)
+            end   
+            
+            
+            align ||= e.to_s =~ NUMBER_PATTERN ? :right : :left 
+            
+            case e
+            when Prawn::Table::Cell
+              e.document = @document
+              e.width    = @column_widths[col_index]
+              e.horizontal_padding = C(:horizontal_padding)
+              e.vertical_padding   = C(:vertical_padding)    
+              e.border_width       = C(:border_width)
+              e.border_style       = :sides
+              e.align              = align 
+              c << e
+            else
+              text = e.is_a?(Hash) ? e[:text] : e.to_s
+              width = if e.is_a?(Hash) && e.has_key?(:colspan)
+                @column_widths.slice(col_index, e[:colspan]).inject { 
+                  |sum, width| sum + width }
+              else
+                @column_widths[col_index]
+              end
+              
+              cell_options = {:document => @document, 
+                :text     => text,
+                :width    => width,
+                :horizontal_padding => C(:horizontal_padding),
+                :vertical_padding   => C(:vertical_padding),
+                :border_width       => C(:border_width),
+                :border_style       => :sides,
+                :align              => align}
+              cell_options[:font_style] = e[:font_style] if e.is_a?(Hash) && e.has_key?(:font_style)
+              cell_options[:font_size] = e[:font_size] if e.is_a?(Hash) && e.has_key?(:font_size)
+
+              c << Prawn::Table::Cell.new(cell_options)
+            end
+            
+            col_index += (e.is_a?(Hash) && e.has_key?(:colspan)) ? e[:colspan] : 1
+          end
+                                              
+          bbox = @parent_bounds.stretchy? ? @document.margin_box : @parent_bounds
+          if c.height > y_pos - bbox.absolute_bottom
+            if C(:headers) && page_contents.length == 1
+              @document.start_new_page
+              y_pos = @document.y
+            else
+              draw_page(page_contents)
+              @document.start_new_page
+              if C(:headers) && page_contents.any?
+                page_contents = [page_contents[0]]
+                y_pos = @document.y - page_contents[0].height
+              else
+                page_contents = []
+                y_pos = @document.y
+              end
+            end
+          end
+
+          page_contents << c
+
+          y_pos -= c.height
+
+          if index == renderable_data.length - 1
+            draw_page(page_contents)
+          end
+
+        end
+      end
+    end
+
+    def draw_page(contents)
+      return if contents.empty?
+
+      if C(:border_style) == :underline_header
+        contents.each { |e| e.border_style = :none }
+        contents.first.border_style = :bottom_only if C(:headers)
+      elsif C(:border_style) == :grid || contents.length == 1
+        contents.each { |e| e.border_style = :all }
+      else
+        contents.first.border_style = C(:headers) ? :all : :no_bottom
+        contents.last.border_style = :no_top
+      end
+      
+      if C(:headers)
+        contents.first.cells.each_with_index do |e,i|
+          if C(:align_headers)
+            case C(:align_headers)
+              when Hash
+                align = C(:align_headers)[i]
+              else
+                align = C(:align_headers)
+              end
+          end
+          e.align = align if align
+          e.text_color = C(:header_text_color) if C(:header_text_color)
+          e.background_color = C(:header_color) if C(:header_color)
+        end
+      end
+      
+      contents.each do |x|
+        unless x.background_color
+          x.background_color = next_row_color if C(:row_colors)
+        end
+        x.border_color = C(:border_color) if C(:border_color)
+        
+        x.draw 
+      end
+
+      reset_row_colors
+    end
+
+
+    def next_row_color
+      color = C(:row_colors).shift
+      C(:row_colors).push(color)
+      color
+    end
+
+    def reset_row_colors    
+      C(:row_colors => C(:original_row_colors).dup) if C(:row_colors)
+    end
+
+  end
+end