pdf-wrapper 0.2.1 → 0.3.0

data/CHANGELOG

@@ -1,3 +1,8 @@
+v0.3.0 (15th October 2009)
+- remove some deprecated functions from Table
+- added support for table cells with text and images
+- no API incompatible changes to 0.2.1
+
 v0.2.1 (18th November 2008)
 - Small bugfix to prevent unnecesary STDERR output by pango
 

data/Rakefile

@@ -5,8 +5,10 @@ require 'rake/rdoctask'
 require 'rake/testtask'
 require "rake/gempackagetask"
 require 'spec/rake/spectask'
+require 'roodi'
+require 'roodi_task'
 
-PKG_VERSION = "0.2.1"
+PKG_VERSION = "0.3.0"
 PKG_NAME = "pdf-wrapper"
 PKG_FILE_NAME = "#{PKG_NAME}-#{PKG_VERSION}"
 
@@ -84,3 +86,5 @@ Rake::GemPackageTask.new(spec) do |pkg|
   pkg.need_zip = true
   pkg.need_tar = true
 end
+
+RoodiTask.new 'roodi', ['lib/**/*.rb']

data/examples/table.rb

@@ -31,6 +31,7 @@ table = PDF::Wrapper::Table.new(:font_size => 10) do |t|
   t.col_options 3, {:alignment => :centre, :border => "tb"}
   t.col_options :even, {:fill_color => :blue}
   t.cell_options 3, 3, {:fill_color => :green}
+  #t.manual_col_width 0, 200
 end
 
 pdf.table(table)

data/examples/table_images.rb

@@ -0,0 +1,41 @@
+#!/usr/bin/env ruby
+# coding: utf-8
+
+$:.unshift(File.dirname(__FILE__) + "/../lib")
+
+require 'pdf/wrapper'
+
+pdf = PDF::Wrapper.new("image_table.pdf", :paper => :A4)
+pdf.text File.read(File.dirname(__FILE__) + "/../specs/data/utf8.txt").strip, :alignment => :centre
+pdf.pad 5
+headers = %w{one two three four}
+
+image_cell = PDF::Wrapper::TextImageCell.new("9781857233001", File.dirname(__FILE__) + "/../specs/data/orc.svg", 150, 100)
+
+data = []
+data << ["This is some longer text to ensure that the cell wraps","oh noes! the cols can't get the width they desire",3,4]
+data << ["This is some longer text to ensure that the cell wraps","oh noes! the cols can't get the width they desire",3,4]
+data << [image_cell,2,3,4]
+
+data << [[], "j", "a", "m"]
+
+(1..100).each do
+  data << %w{1 2 3 4}
+end
+
+table = PDF::Wrapper::Table.new(:font_size => 10) do |t|
+  t.data = data
+  t.headers headers, {:color => :white, :fill_color => :black}
+  t.row_options 6, {:border => "t"}
+  t.row_options :even, {:fill_color => :gray}
+  t.col_options 0, {:border => "tb"}
+  t.col_options 1, {:alignment => :centre}
+  t.col_options 2, {:alignment => :centre}
+  t.col_options 3, {:alignment => :centre, :border => "tb"}
+  t.col_options :even, {:fill_color => :blue}
+  t.cell_options 3, 3, {:fill_color => :green}
+  #t.manual_col_width 0, 200
+end
+
+pdf.table(table)
+pdf.finish

data/examples/table_simple.rb

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby
+# coding: utf-8
+
+$:.unshift(File.dirname(__FILE__) + "/../lib")
+
+require 'pdf/wrapper'
+
+pdf = PDF::Wrapper.new("table.pdf", :paper => :A4)
+
+data = []
+data << ["This is some longer text to ensure that the cell wraps","oh noes! the cols can't get the width they desire",3,4]
+data << ["This is some longer text to ensure that the cell wraps","oh noes! the cols can't get the width they desire",3,4]
+data << [[], "j", "a", "m"]
+
+(1..100).each do
+  data << %w{1 2 3 4}
+end
+
+pdf.table(data)
+pdf.finish

data/lib/pdf/wrapper.rb

@@ -9,6 +9,8 @@ require 'fileutils'
 require File.dirname(__FILE__) + "/wrapper/graphics"
 require File.dirname(__FILE__) + "/wrapper/images"
 require File.dirname(__FILE__) + "/wrapper/loading"
+require File.dirname(__FILE__) + "/wrapper/text_cell"
+require File.dirname(__FILE__) + "/wrapper/text_image_cell"
 require File.dirname(__FILE__) + "/wrapper/table"
 require File.dirname(__FILE__) + "/wrapper/text"
 require File.dirname(__FILE__) + "/wrapper/page"

data/lib/pdf/wrapper/table.rb

@@ -1,8 +1,10 @@
 module PDF
   class Wrapper
 
-    # Draws a basic table of text on the page. See the documentation for a detailed description of
-    # how to control the table and its appearance.
+    # Draws a basic table of text on the page. See the documentation for PDF::Wrapper::Table to get
+    # a detailed description of how to control the table and its appearance. If data is an array,
+    # it can contain Cell-like objects (see PDF::Wrapper::TextCell and PDF::Wrapper::TextImageCell)
+    # or any objects that respond to to_s().
     #
     # <tt>data</tt>:: a 2d array with the data for the columns, or a PDF::Wrapper::Table object
     #
@@ -17,7 +19,7 @@ module PDF
     # <tt>:width</tt>::   The width of the table. Defaults to the distance from the left of the table to the right margin
     def table(data, opts = {})
       # TODO: add support for a table footer
-      #       - repeating each page, or just at the bottom? 
+      #       - repeating each page, or just at the bottom?
       #       - if it repeats, should it be different on each page? ie. a sum of that pages rows, etc.
       # TODO: maybe support for multiple data sets with group headers/footers. useful for subtotals, etc
 
@@ -35,137 +37,13 @@ module PDF
       end
 
       t.width = options[:width] || points_to_right_margin(options[:left])
-      calc_table_dimensions t
-
-      # move to the start of our table (the top left)
-      move_to(options[:left], options[:top])
-
-      # draw the header cells
-      draw_table_headers(t) if t.headers && (t.show_headers == :page || t.show_headers == :once)
-
-      x, y = current_point
-
-      # loop over each row in the table
-      t.cells.each_with_index do |row, row_idx|
-
-        # calc the height of the current row
-        h = t.row_height(row_idx)
-
-        if y + h > absolute_bottom_margin
-          start_new_page
-          y = margin_top
-
-          # draw the header cells
-          draw_table_headers(t) if t.headers && (t.show_headers == :page)
-          x, y = current_point
-        end
-
-        # loop over each column in the current row
-        row.each_with_index do |cell, col_idx|
-
-          # calc the options and widths for this particular cell
-          opts = t.options_for(col_idx, row_idx)
-          w = t.col_width(col_idx)
-
-          # paint it
-          self.cell(cell.data, x, y, w, h, opts)
-          x += w
-          move_to(x, y)
-        end
-
-        # move to the start of the next row
-        y += h
-        x = options[:left]
-        move_to(x, y)
-      end
-    end
-    
-    def calc_table_dimensions(t)
-      # TODO: when calculating the min cell width, we basically want the width of the widest character. At the
-      #       moment I'm stripping all pango markup tags from the string, which means if any character is made
-      #       intentioanlly large, we'll miss it and it might not fit into our table cell.
-
-      # calculate the min and max width of every cell in the table
-      t.cells.each_with_index do |row, row_idx|
-        row.each_with_index do |cell, col_idx|
-          opts = t.options_for(col_idx, row_idx).only(default_text_options.keys)
-          padding = opts[:padding] || 3
-          if opts[:markup] == :pango
-            str = cell.data.to_s.dup.gsub(/<.+?>/,"").gsub("&amp;","&").gsub("&lt;","<").gsub("&gt;",">")
-            opts.delete(:markup)
-          else
-            str = cell.data.to_s.dup
-          end
-          cell.min_width  = text_width(str.gsub(/\b|\B/,"\n"), opts) + (padding * 4)
-          cell.max_width  = text_width(str, opts) + (padding * 4)
-        end
-      end
-
-      # calculate the min and max width of every cell in the headers row
-      if t.headers
-        t.headers.each_with_index do |cell, col_idx|
-          opts = t.options_for(col_idx, :headers).only(default_text_options.keys)
-          padding = opts[:padding] || 3
-          if opts[:markup] == :pango
-            str = cell.data.to_s.dup.gsub(/<.+?>/,"").gsub("&amp;","&").gsub("&lt;","<").gsub("&gt;",">")
-            opts.delete(:markup)
-          else
-            str = cell.data.to_s.dup
-          end
-          cell.min_width  = text_width(str.gsub(/\b|\B/,"\n"), opts) + (padding * 4)
-          cell.max_width  = text_width(str, opts) + (padding * 4)
-        end
-      end
-
-      # let the table decide on the actual widths it will use for each col
-      t.calc_col_widths!
-
-      # now that we know how wide each column will be, we can calculate the
-      # height of every cell in the table
-      t.cells.each_with_index do |row, row_idx|
-        row.each_with_index do |cell, col_idx|
-          opts = t.options_for(col_idx, row_idx).only(default_text_options.keys)
-          padding = opts[:padding] || 3
-          cell.height = text_height(cell.data, t.col_width(col_idx) - (padding * 2), opts) + (padding * 2)
-        end
-      end
-
-      # let the table calculate how high each row is going to be
-      t.calc_row_heights!
-
-      # perform the same height calcs for the header row if necesary
-      if t.headers
-        t.headers.each_with_index do |cell, col_idx|
-          opts = t.options_for(col_idx, :headers).only(default_text_options.keys)
-          padding = opts[:padding] || 3
-          cell.height = text_height(cell.data, t.col_width(col_idx) - (padding * 2), opts) + (padding * 2)
-        end
-        t.calc_headers_height!
-      end
-    end
-    private :calc_table_dimensions
-
-    def draw_table_headers(t)
-      x, y = current_point
-      origx = x
-      h = t.headers_height
-      t.headers.each_with_index do |cell, col_idx|
-        # calc the options and widths for this particular header cell
-        opts = t.options_for(col_idx, :headers)
-        w = t.col_width(col_idx)
-
-        # paint it
-        self.cell(cell.data, x, y, w, h, opts)
-        x += w
-        move_to(x, y)
-      end
-      move_to(origx, y + h)
+      t.draw(self, options[:left], options[:top])
     end
-    private :draw_table_headers
 
     # This class is used to hold all the data and options for a table that will
     # be added to a PDF::Wrapper document. Tables are a collection of cells, each
-    # one rendered to the document using the Wrapper#cell function.
+    # one individually rendered to the document in a location that makes it appear
+    # to be a table.
     #
     # To begin working with a table, pass in a 2d array of data to display, along
     # with optional headings, then pass the object to Wrapper#table
@@ -178,13 +56,13 @@ module PDF
     #    end
     #    pdf.table(table)
     #
-    # For all but the most basic tables, you will probably want to tweak at least 
+    # For all but the most basic tables, you will probably want to tweak at least
     # some of the options for some of the cells. The options available are the same
     # as those that are valid for the Wrapper#cell method, including things like font,
     # font size, color and alignment.
     #
     # Options can be specified at the table, column, row and cell level. When it comes time
-    # to render each cell, the options are merged together so that cell options override row 
+    # to render each cell, the options are merged together so that cell options override row
     # ones, row ones override column ones and column ones override table wide ones.
     #
     # By default, no options are defined at all, and the document defaults will be used.
@@ -211,39 +89,73 @@ module PDF
     # to change this behaviour. Valid values are nil for never, :once for just the at the
     # top of the table, and :page for the default.
     #
+    # == Complex Cells
+    #
+    # By default, any cell content described in the data array is converted to a string and
+    # wrapped in a TextCell object. If you need to, it is possible to define your cells
+    # as cell-like objects manually to get more control.
+    #
+    # The following two calls are equivilant:
+    #
+    #   data = [[1,2]]
+    #   pdf.table(data)
+    #
+    #   data = [[PDF::Wrapper::TextCell.new(2),PDF::Wrapper::TextCell.new(2)]]
+    #   pdf.table(data)
+    #
+    # An alternative to a text-only cell is a cell with text and an image. These
+    # cells must be initialised with a filename and cell dimensions (width and height)
+    # as calculating automatic dimensions is difficult.
+    #
+    #   data = [
+    #     ["James", PDF::Wrapper::TextImageCell.new("Healy","photo-jim.jpg",100,100)],
+    #     ["Jess", PDF::Wrapper::TextImageCell.new("Healy","photo-jess.jpg",100,100)],
+    #   ]
+    #   pdf.table(data)
+    #
+    # If TextImageCell doesn't meet your needs, you are free to define your own
+    # cell-like object and use that.
+    #
     class Table
-      attr_reader :cells#, :headers
+      attr_reader :cells, :wrapper
       attr_accessor :width, :show_headers
 
-      #
       def initialize(opts = {})
 
         # default table options
         @table_options  = opts
-        @col_options    = Hash.new({})
-        @row_options    = Hash.new({})
         @manual_col_widths = {}
-        @header_options = {}
         @show_headers  = :page
 
         yield self if block_given?
         self
       end
 
-      # Specify the tables data.
+      # Set the table data.
       #
       # The single argument should be a 2d array like:
       #
       #   [[ "one", "two"],
       #    [ "one", "two"]]
+      #
+      # The cells in the array can be any object with to_s() defined, or a Cell-like
+      # object (such as a TextCell or TextImageCell).
+      #
       def data=(d)
-        # TODO: raise an exception of the data rows aren't all the same size
-        # TODO: ensure d is array-like
+        row_sizes = d.map { |row| row.size }.compact.uniq
+        raise ArgumentError, "" if row_sizes.size > 1
+
         @cells = d.collect do |row|
-          row.collect do |str|
-            Wrapper::Cell.new(str)
+          row.collect do |data|
+            if data.kind_of?(Wrapper::TextCell) || data.kind_of?(Wrapper::TextImageCell)
+              data
+            else
+              Wrapper::TextCell.new(data.to_s)
+            end
           end
         end
+        each_cell { |cell| cell.options.merge!(@table_options)}
+        @cells
       end
 
       # Retrieve or set the table's optional column headers.
@@ -258,57 +170,78 @@ module PDF
       #   t.headers ["col one", "col two]
       #
       # The optional second argument sets the cell options for the header
-      # cells. See PDF::Wrapper#cell for a list of possible options. 
+      # cells. See PDF::Wrapper#cell for a list of possible options.
       #
       #   t.headers ["col one", "col two], :color => :block, :fill_color => :black
       #
-      # If the options hash is left unspecified, the default table options will 
+      # If the options hash is left unspecified, the default table options will
       # be used.
       #
       def headers(h = nil, opts = {})
-        # TODO: raise an exception of the size of the array does not match the size
-        #       of the data row arrays
-        # TODO: ensure h is array-like
         return @headers if h.nil?
-        @headers = h.collect do |str|
-          Wrapper::Cell.new(str)
+
+        if @cells && @cells.first.size != h.size
+          raise ArgumentError, "header column count does not match data column count"
         end
-        @header_options = opts
-      end
 
-      def headers=(h)
-        # TODO: remove this method at some point. Deprecation started on 10th August 2008.
-        warn "WARNING: Table#headers=() is deprecated, headers should now be set along with header options using Table#headers()"
-        headers h
+        @headers = h.collect do |data|
+          if data.kind_of?(Wrapper::TextCell) || data.kind_of?(Wrapper::TextImageCell)
+            data
+          else
+            Wrapper::TextCell.new(data.to_s)
+          end
+        end
+        @headers.each { |cell| cell.options.merge!(@table_options)}
+        @headers.each { |cell| cell.options.merge!(opts)}
+        @headers
       end
 
-      # access a particular cell at location x, y
-      def cell(col_idx, row_idx)
-        @cells[row_idx, col_idx]
-      end
+      def draw(wrapper, tablex, tabley)
+        @wrapper = wrapper
 
-      # Set or retrieve options that apply to every cell in the table.
-      # For a list of valid options, see Wrapper#cell.
-      #
-      # WARNING. This method is deprecated. Table options should be passed to the
-      #          PDF::Wrapper::Table constructor instead
-      def table_options(opts = nil)
-        # TODO: remove this method at some point. Deprecation started on 10th August 2008.
-        warn "WARNING: Table#table_options() is deprecated, please see the documentation for PDF::Wrapper::Table"
-        @table_options = @table_options.merge(opts) if opts
-        @table_options
+        calculate_dimensions
+
+        # move to the start of our table (the top left)
+        wrapper.move_to(tablex, tabley)
+
+        # draw the header cells
+        draw_table_headers if self.headers && (self.show_headers == :page || self.show_headers == :once)
+
+        x, y = wrapper.current_point
+
+        # loop over each row in the table
+        self.cells.each_with_index do |row, row_idx|
+
+          # calc the height of the current row
+          h = row.first.height
+
+          if y + h > wrapper.absolute_bottom_margin
+            wrapper.start_new_page
+            y = wrapper.margin_top
+
+            # draw the header cells
+            draw_table_headers if self.headers && (self.show_headers == :page)
+            x, y = wrapper.current_point
+          end
+
+          # loop over each column in the current row and paint it
+          row.each_with_index do |cell, col_idx|
+            cell.draw(wrapper, x, y)
+            x += cell.width
+            wrapper.move_to(x, y)
+          end
+
+          # move to the start of the next row
+          y += h
+          x = tablex
+          wrapper.move_to(x, y)
+        end
       end
 
-      # set or retrieve options that apply to header cells
-      # For a list of valid options, see Wrapper#cell.
+      # access a particular cell at location x, y
       #
-      # WARNING. This method is deprecated. Header options should be passed to the
-      #          PDF::Wrapper::Table#headers method instead
-      def header_options(opts = nil)
-        # TODO: remove this method at some point. Deprecation started on 10th August 2008.
-        warn "WARNING: Table#header_options() is deprecated, please see the documentation for PDF::Wrapper::Table"
-        @header_options = @header_options.merge(opts) if opts
-        @header_options
+      def cell(col_idx, row_idx)
+        @cells[row_idx][col_idx]
       end
 
       # set or retrieve options that apply to a single cell
@@ -329,14 +262,16 @@ module PDF
              (spec.class == Range && spec.include?(col_idx)) ||
              (spec.class == Array && spec.include?(col_idx)) ||
              (spec.respond_to?(:to_i) && spec.to_i == col_idx)
-            
-            @col_options[col_idx] = @col_options[col_idx].merge(opts)
+
+            cells_in_col(col_idx).each do |cell|
+              cell.options.merge!(opts)
+            end
           end
         end
         self
       end
 
-      # Manually set the width for 1 or more columns 
+      # Manually set the width for 1 or more columns
       #
       # <tt>spec</tt>::     Which columns to set the width for. :odd, :even, a range, an Array of numbers or a number
       #
@@ -348,7 +283,7 @@ module PDF
              (spec.class == Range && spec.include?(col_idx)) ||
              (spec.class == Array && spec.include?(col_idx)) ||
              (spec.respond_to?(:to_i) && spec.to_i == col_idx)
-            
+
             @manual_col_widths[col_idx] = width
           end
         end
@@ -365,174 +300,172 @@ module PDF
              (spec.class == Range && spec.include?(row_idx)) ||
              (spec.class == Array && spec.include?(row_idx)) ||
              (spec.respond_to?(:to_i) && spec.to_i == row_idx)
-            
-            @row_options[row_idx] = @col_options[row_idx].merge(opts)
+
+            cells_in_row(row_idx).each do |cell|
+              cell.options.merge!(opts)
+            end
           end
         end
         self
       end
 
-      # calculate the combined options for a particular cell
-      #
-      # To get the options for a regular cell, use numbers to reference the exact cell:
-      #
-      #    options_for(3, 3)
-      #
-      # To get options for a header cell, use :headers for the row:
-      #
-      #    options_for(3, :headers)
+      # Returns the number of columns in the table
+      def col_count
+        @cells.first.size.to_f
+      end
+
+      # iterate over each cell in the table. Yields a cell object.
       #
-      def options_for(col_idx, row_idx = nil)
-        opts = @table_options.dup
-        opts.merge! @col_options[col_idx]
-        if row_idx == :headers
-          opts.merge! @header_options
-        else
-          opts.merge! @row_options[row_idx]
-          opts.merge! @cells[row_idx][col_idx].options
+      def each_cell(&block)
+        each_row do |row_idx|
+          cells_in_row(row_idx).each do |cell|
+            yield cell
+          end
         end
-        opts
       end
 
-      # Returns the required height for the headers row.
-      # Essentially just the height of the tallest cell in the row.
-      def headers_height
-        raise "You must call calc_headers_height! before calling headers_height" if @headers_height.nil?
-        @headers_height
-      end
+      private
 
-      # Returns the required height for a particular row.
-      # Essentially just the height of the tallest cell in the row.
-      def row_height(idx)
-        raise "You must call calc_row_heights! before calling row_heights" if @row_heights.nil?
-        @row_heights[idx]
+      def draw_table_headers
+        x, y = wrapper.current_point
+        origx = x
+        h = self.headers.first.height
+        self.headers.each_with_index do |cell, col_idx|
+          cell.draw(wrapper, x, y)
+          x += cell.width
+          wrapper.move_to(x, y)
+        end
+        wrapper.move_to(origx, y + h)
       end
 
-      # Returns the number of columns in the table
-      def col_count
-        @cells.first.size.to_f
+      # calculate the dimensions of each row and column in the table. The order
+      # here is crucial. First we ask each cell to caclulate the range of
+      # widths they can render with, then we make a decision on the actual column
+      # width and pass that on to every cell.
+      #
+      # Once each cell knows how wide it will be it can calculate how high it
+      # will be. With that done the table cen determine the tallest cell in
+      # each row and pass that onto each cell so every cell in a row renders
+      # with the same height.
+      #
+      def calculate_dimensions
+        calculate_cell_width_range
+        calculate_column_widths
+        calculate_cell_heights
+        calculate_row_heights
       end
 
-      # Returns the width of the specified column
-      def col_width(idx)
-        raise "You must call calc_col_widths! before calling col_width" if @col_widths.nil?
-        @col_widths[idx]
-      end
+      def calculate_cell_width_range
+        # TODO: when calculating the min cell width, we basically want the width of the widest character. At the
+        #       moment I'm stripping all pango markup tags from the string, which means if any character is made
+        #       intentioanlly large, we'll miss it and it might not fit into our table cell.
 
-      # process the individual cell widths and decide on the resulting
-      # width of each column in the table
-      def calc_col_widths!
-        @col_widths = calc_column_widths
+        # calculate the min and max width of every cell in the table
+        cells.each_with_index do |row, row_idx|
+          row.each_with_index do |cell, col_idx|
+            cell.calculate_width_range(wrapper)
+          end
+        end
+
+        # calculate the min and max width of every cell in the headers row
+        if self.headers
+          self.headers.each_with_index do |cell, col_idx|
+            cell.calculate_width_range(wrapper)
+          end
+        end
       end
 
-      # process the individual cell heights in the header and decide on the 
-      # resulting height of each row in the table
-      def calc_headers_height!
-        @headers_height = @headers.collect { |cell| cell.height }.compact.max
+      def calculate_cell_heights
+        cells.each_with_index do |row, row_idx|
+          row.each_with_index do |cell, col_idx|
+            cell.calculate_height(wrapper)
+          end
+        end
+
+        # perform the same height calcs for the header row if necesary
+        if self.headers
+          self.headers.each_with_index do |cell, col_idx|
+            cell.calculate_height(wrapper)
+          end
+        end
       end
 
       # process the individual cell heights and decide on the resulting
       # height of each row in the table
-      def calc_row_heights!
-        @row_heights = @cells.collect do |row|
-          row.collect { |cell| cell.height }.compact.max
+      def calculate_row_heights
+        @cells.each do |row|
+          row_height = row.collect { |cell| cell.height }.compact.max
+          row.each { |cell| cell.height = row_height }
         end
-      end
 
-      # forget row and column dimensions
-      def reset!
-        @col_widths = nil
-        @row_heights = nil
+        if @headers
+          row_height = @headers.collect { |cell| cell.height }.compact.max
+          self.headers.each_with_index do |cell, col_idx|
+            cell.height = row_height
+          end
+        end
       end
 
-      private
-
       # the main smarts behind deciding on the width of each column. If possible,
       # each cell will get the maximum amount of space it wants. If not, some
       # negotiation happens to find the best possible set of widths.
-      def calc_column_widths
+      #
+      def calculate_column_widths
         raise "Can't calculate column widths without knowing the overall table width" if self.width.nil?
-        check_cell_widths
 
-        max_col_widths = {}
         min_col_widths = {}
+        natural_col_widths = {}
+        max_col_widths = {}
         each_column do |col|
-          min_col_widths[col] = cells_in_col(col).collect { |c| c.min_width}.max.to_f
-          max_col_widths[col] = cells_in_col(col).collect { |c| c.max_width}.max.to_f
-        end
-        # add header cells to the mix
-        if @headers
-          @headers.each_with_index do |cell, idx|
-            min_col_widths[idx] = [cell.min_width.to_f, min_col_widths[idx]].max
-            max_col_widths[idx] = [cell.max_width.to_f, max_col_widths[idx]].max
-          end
+          min_col_widths[col] = cells_in_col(col).collect { |c| c.min_width}.max
+          natural_col_widths[col] = cells_in_col(col).collect { |c| c.natural_width}.max
+          max_col_widths[col] = cells_in_col(col).collect { |c| c.max_width}.compact.max
         end
 
         # override the min and max col widths with manual ones where appropriate
-        # freeze the values so that the algorithm that adjusts the widths
-        # leaves them untouched
-        @manual_col_widths.each { |key, val| val.freeze }
         max_col_widths.merge! @manual_col_widths
+        natural_col_widths.merge! @manual_col_widths
         min_col_widths.merge! @manual_col_widths
 
         if min_col_widths.values.sum > self.width
           raise RuntimeError, "table content cannot fit into a table width of #{self.width}"
-        end
-        
-        if max_col_widths.values.sum == self.width
-          # every col gets the space it wants
-          col_widths = max_col_widths.dup
-        elsif max_col_widths.values.sum < self.width
-          # every col gets the space it wants, and there's
-          # still more room left. Distribute the extra room evenly
-          col_widths = grow_col_widths(max_col_widths.dup, max_col_widths, true)
         else
           # there's not enough room for every col to get as much space
           # as it wants, so work our way down until it fits
-          col_widths = grow_col_widths(min_col_widths.dup, max_col_widths, false)
-        end
-        col_widths
-      end
-
-      # check to ensure every cell has a minimum and maximum cell width defined
-      def check_cell_widths
-        @cells.each do |row|
-          row.each_with_index do |cell, col_idx|
-            raise "Every cell must have a min_width defined before being rendered to a document" if cell.min_width.nil?
-            raise "Every cell must have a max_width defined before being rendered to a document" if cell.max_width.nil?
-            if @manual_col_widths[col_idx] && cell.min_width > @manual_col_widths[col_idx]
-              raise "Manual width for col #{col_idx} is too low"
-            end
-          end
-        end
-        if @headers
-          @headers.each_with_index do |cell, col_idx|
-            raise "Every header cell must have a min_width defined before being rendered to a document" if cell.min_width.nil?
-            raise "Every header cell must have a max_width defined before being rendered to a document" if cell.max_width.nil?
-            if @manual_col_widths[col_idx] && cell.min_width > @manual_col_widths[col_idx]
-              raise "Manual width for col #{col_idx} is too low"
+          col_widths = grow_col_widths(min_col_widths.dup, natural_col_widths, max_col_widths)
+          col_widths.each do |col_index, width|
+            cells_in_col(col_index).each do |cell|
+              cell.width = width
             end
           end
         end
       end
 
-      # iterate over each column in the table
+      # iterate over each column in the table. Yields a column index, not
+      # actual columns or cells.
+      #
       def each_column(&block)
         (0..(col_count-1)).each do |col|
           yield col
         end
       end
 
-      # iterate over each row in the table
+      # iterate over each row in the table. Yields an row index, not actual rows
+      # or cells.
+      #
       def each_row(&block)
         (0..(@cells.size-1)).each do |row|
           yield row
         end
       end
 
-      # an array of all the cells in the specified column
+      # an array of all the cells in the specified column, including headers
+      #
       def cells_in_col(idx)
-        @cells.collect {|row| row[idx]}
+        ret = []
+        ret << @headers[idx] if @headers
+        ret += @cells.collect {|row| row[idx]}
+        ret
       end
 
       # an array of all the cells in the specified row
@@ -540,17 +473,35 @@ module PDF
         @cells[idx]
       end
 
-      # if the widths of every column are less than the total width
-      # of the table, grow them to make use of it.
+      # starting with very low widths for each col, bump each column width up
+      # until we reach the width of the entire table.
+      #
+      # columns that are less than their "natural width" are given preference.
+      # If every column has reached its natural width then each column is
+      # increased in an equal manor.
       #
-      # col_widths - the current hash of widths for each column index
-      # max_col_widths - the maximum width each column desires
-      # past_max - can the width of a colum grow beyond its maximum desired
-      def grow_col_widths(col_widths, max_col_widths, past_max = false)
+      # starting col_widths 
+      #     the hash of column widths to start from. Should generally match the
+      #     absolute smallest width each column can render in
+      # natural_col_widths
+      #     the hqash of column widths where each column will be able to render
+      #     itself fully without wrapping
+      # max_col_widths 
+      #     the hash of absolute maximum column widths, no column width can go
+      #     past this. Can be nil, which indicates there's no maximum
+      #
+      def grow_col_widths(starting_col_widths, natural_col_widths, max_col_widths)
+        col_widths = starting_col_widths.dup
         loop do
           each_column do |idx|
-            col_widths[idx] += 0.3 unless col_widths[idx].frozen?
-            col_widths[idx].freeze if col_widths[idx] >= max_col_widths[idx] && past_max == false
+            if col_widths.values.sum >= natural_col_widths.values.sum ||
+                 col_widths[idx] < natural_col_widths[idx]
+              if max_col_widths[idx].nil? || col_widths[idx] < max_col_widths[idx]
+                col_widths[idx] += 0.3
+              else
+                col_widths[idx] = max_col_widths[idx]
+              end
+            end
             break if col_widths.values.sum >= self.width
           end
           break if col_widths.values.sum >= self.width
@@ -558,15 +509,5 @@ module PDF
         col_widths
       end
     end
-
-    # A basic container to hold the required information for each cell
-    class Cell
-      attr_accessor :data, :options, :height, :min_width, :max_width
-
-      def initialize(str)
-        @data = str
-        @options = {}
-      end
-    end
   end
 end