fullcirclegroup-prawn 0.2.99.3

data/lib/prawn/document/internals.rb

@@ -0,0 +1,113 @@
+module Prawn
+  class Document     
+    
+    # This module exposes a few low-level PDF features for those who want
+    # to extend Prawn's core functionality.  If you are not comfortable with
+    # low level PDF functionality as defined by Adobe's specification, chances
+    # are you won't need anything you find here.  
+    #
+    module Internals    
+      # Creates a new Prawn::Reference and adds it to the Document's object
+      # list.  The +data+ argument is anything that Prawn::PdfObject() can convert.    
+      def ref(data)
+        @objects.push(Prawn::Reference.new(@objects.size + 1, data)).last
+      end                                               
+      
+      # Appends a raw string to the current page content.
+      #                               
+      #  # Raw line drawing example:           
+      #  x1,y1,x2,y2 = 100,500,300,550
+      #  pdf.add_content("%.3f %.3f m" % [ x1, y1 ])  # move 
+      #  pdf.add_content("%.3f %.3f l" % [ x2, y2 ])  # draw path
+      #  pdf.add_content("S") # stroke                    
+      #
+      def add_content(str)
+       @page_content << str << "\n"
+      end  
+
+      # Add a new type to the current pages ProcSet 
+      #
+      def proc_set(*types)
+        @current_page.data[:ProcSet] ||= ref([])
+        @current_page.data[:ProcSet].data |= types
+      end
+             
+      # The Resources dictionary for the current page
+      #
+      def page_resources
+        @current_page.data[:Resources] ||= {}
+      end
+      
+      # The Font dictionary for the current page
+      #
+      def page_fonts
+        page_resources[:Font] ||= {}
+      end
+       
+      # The XObject dictionary for the current page
+      def page_xobjects
+        page_resources[:XObject] ||= {}
+      end  
+      
+      # The Name dictionary (PDF spec 3.6.3) for this document. It is
+      # lazily initialized, so that documents that do not need a name
+      # dictionary do not incur the additional overhead.
+      def names
+        @root.data[:Names] ||= ref(:Type => :Names)
+      end
+
+      private      
+      
+      def finish_page_content     
+        @header.draw if @header      
+        @footer.draw if @footer
+        add_content "Q"
+        @page_content.compress_stream if compression_enabled?
+        @page_content.data[:Length] = @page_content.stream.size
+      end
+
+      # Write out the PDF Header, as per spec 3.4.1
+      def render_header(output)
+        # pdf version
+        output << "%PDF-1.3\n"
+
+        # 4 binary chars, as recommended by the spec
+        output << "\xFF\xFF\xFF\xFF\n"
+      end
+
+      # Write out the PDF Body, as per spec 3.4.2
+      def render_body(output)
+        @objects.each do |ref|
+          ref.offset = output.size
+          output << ref.object
+        end
+      end
+
+      # Write out the PDF Cross Reference Table, as per spec 3.4.3
+      def render_xref(output)
+        @xref_offset = output.size
+        output << "xref\n"
+        output << "0 #{@objects.size + 1}\n"
+        output << "0000000000 65535 f \n"
+        @objects.each do |ref|
+          output.printf("%010d", ref.offset)
+          output << " 00000 n \n"
+        end
+      end
+
+      # Write out the PDF Body, as per spec 3.4.4
+      def render_trailer(output)
+        trailer_hash = {:Size => @objects.size + 1, 
+                        :Root => @root,
+                        :Info => @info}
+
+        output << "trailer\n"
+        output << Prawn::PdfObject(trailer_hash) << "\n"
+        output << "startxref\n" 
+        output << @xref_offset << "\n"
+        output << "%%EOF"
+      end
+                 
+    end
+  end
+end

data/lib/prawn/document/page_geometry.rb

@@ -0,0 +1,79 @@
+# encoding: utf-8
+
+# page_geometry.rb : Describes PDF page geometries
+#
+# Copyright April 2008, Gregory Brown.  All Rights Reserved.
+#
+# This is free software. Please see the LICENSE and COPYING files for details.
+
+module Prawn
+  class Document
+    module PageGeometry
+
+      # Dimensions pulled from PDF::Writer, rubyforge.org/projects/ruby-pdf
+      SIZES = { "4A0" => [4767.87, 6740.79],
+                "2A0" => [3370.39, 4767.87],
+                 "A0" => [2383.94, 3370.39],
+                 "A1" => [1683.78, 2383.94],
+                 "A2" => [1190.55, 1683.78],
+                 "A3" => [841.89, 1190.55],
+                 "A4" => [595.28, 841.89],
+                 "A5" => [419.53, 595.28],
+                 "A6" => [297.64, 419.53],
+                 "A7" => [209.76, 297.64],
+                 "A8" => [147.40, 209.76],
+                 "A9" => [104.88, 147.40],
+                "A10" => [73.70, 104.88],
+                 "B0" => [2834.65, 4008.19],
+                 "B1" => [2004.09, 2834.65],
+                 "B2" => [1417.32, 2004.09],
+                 "B3" => [1000.63, 1417.32],
+                 "B4" => [708.66, 1000.63],
+                 "B5" => [498.90, 708.66],
+                 "B6" => [354.33, 498.90],
+                 "B7" => [249.45, 354.33],
+                 "B8" => [175.75, 249.45],
+                 "B9" => [124.72, 175.75],
+                "B10" => [87.87, 124.72],
+                 "C0" => [2599.37, 3676.54],
+                 "C1" => [1836.85, 2599.37],
+                 "C2" => [1298.27, 1836.85],
+                 "C3" => [918.43, 1298.27],
+                 "C4" => [649.13, 918.43],
+                 "C5" => [459.21, 649.13],
+                 "C6" => [323.15, 459.21],
+                 "C7" => [229.61, 323.15],
+                 "C8" => [161.57, 229.61],
+                 "C9" => [113.39, 161.57],
+                "C10" => [79.37, 113.39],
+                "RA0" => [2437.80, 3458.27],
+                "RA1" => [1729.13, 2437.80],
+                "RA2" => [1218.90, 1729.13],
+                "RA3" => [864.57, 1218.90],
+                "RA4" => [609.45, 864.57],
+               "SRA0" => [2551.18, 3628.35],
+               "SRA1" => [1814.17, 2551.18],
+               "SRA2" => [1275.59, 1814.17],
+               "SRA3" => [907.09, 1275.59],
+               "SRA4" => [637.80, 907.09],
+          "EXECUTIVE" => [521.86, 756.00],
+              "FOLIO" => [612.00, 936.00],
+              "LEGAL" => [612.00, 1008.00],
+             "LETTER" => [612.00, 792.00],
+            "TABLOID" => [792.00, 1224.00] }
+
+      def page_dimensions #:nodoc:
+        coords = SIZES[page_size] || page_size
+        [0,0] + case(page_layout)
+        when :portrait
+          coords
+        when :landscape
+          coords.reverse
+        else
+          raise Prawn::Errors::InvalidPageLayout,
+            "Layout must be either :portrait or :landscape"
+        end
+      end
+    end
+  end
+end

data/lib/prawn/document/span.rb

@@ -0,0 +1,47 @@
+module Prawn
+  class Document
+    # A span is a special purpose bounding box that allows a column of 
+    # elements to be positioned relative to the margin_box.  
+    #
+    # Arguments:
+    # +width+:: The width of the column in PDF points
+    #
+    # Options:
+    # <tt>:position</tt>:: One of :left, :center, :right or an x offset
+    #
+    # This method is typically used for flowing a column of text from one 
+    # page to the next.
+    #
+    #  span(350, :position => :center) do
+    #    text "Here's some centered text in a 350 point column. " * 100
+    #  end
+    #  
+    def span(width, options={})
+      Prawn.verify_options [:position], options
+      original_position = self.y      
+      
+      # FIXME: How many effing times do I want to write this same code?
+      left_boundary = case(options[:position] || :left)
+      when :left
+        margin_box.absolute_left
+      when :center
+        margin_box.absolute_left + margin_box.width / 2.0 - width /2.0
+      when :right
+        margin_box.absolute_right - width
+      when Numeric
+        margin_box.absolute_left + options[:position]
+      else
+        raise ArgumentError, "Invalid option for :position"
+      end
+      
+      # we need to bust out of whatever nested bounding boxes we're in.
+      canvas do
+        bounding_box([left_boundary, 
+                      margin_box.absolute_top], :width => width) do
+          self.y = original_position
+          yield
+        end
+      end          
+    end
+  end
+end

data/lib/prawn/document/table.rb

@@ -0,0 +1,350 @@
+# 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.
+
+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,
+    #                 :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::Document::Table.new(data,self,options).draw
+    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 :col_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>: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 :top_and_bottom, only draws horizontal lines. Otherwise, borders are drawn on columns only, not rows
+      # <tt>:border_header_style</tt>:: Applies the selected style to every header cell. Defaults to :bottom_only
+      # <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>: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>: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>: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_header_style, :border_width,
+         :position, :headers, :row_colors, :align, :align_headers, :header_text_color, :border_color,
+         :horizontal_padding, :vertical_padding, :padding, :widths, 
+         :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[:widths])
+      end                                        
+      
+      attr_reader :col_widths #:nodoc:
+      
+      # Width of the table in PDF points
+      #
+      def width
+         @col_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)
+        @col_widths = [0] * @data[0].length    
+        renderable_data.each do |row|
+          row.each_with_index do |cell,i|
+            length = cell.to_s.lines.map { |e| 
+              @document.font.metrics.string_width(e,C(:font_size)) }.max.to_f +
+                2*C(:horizontal_padding)
+            @col_widths[i] = length.ceil if length > @col_widths[i]
+          end
+        end  
+        
+        manual_widths.each { |k,v| @col_widths[k] = v } if manual_widths           
+      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::Graphics::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::Graphics::Cell
+                e.document = @document
+                e.width    = @col_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)
+                  @col_widths.slice(col_index, e[:colspan]).inject { |sum, width| sum + width }
+                else
+                  @col_widths[col_index]
+                end
+                
+                c << Prawn::Graphics::Cell.new(
+                  :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 ) 
+              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?
+ 
+        # TODO - this will eventually be made redundant
+        if C(:border_style) == :underline_header
+          contents.each { |e| e.border_style = :none }
+          contents.first.border_style = :bottom_only if C(:headers) && C(:header_border_style).nil?
+
+
+        elsif C(:border_style) == :grid || contents.length == 1
+          contents.each { |e| e.border_style = :all }
+
+        elsif C(:border_style) == :top_and_bottom
+          contents.each { |e| e.border_style = :top_and_bottom }
+          
+        else
+          contents.first.border_style = C(:headers) ? :all : :no_bottom
+          contents.last.border_style = :no_top
+        end
+        
+        if C(:headers)
+          
+          if C(:header_border_style)
+            contents.first.border_style = C(:header_border_style)
+          else
+            contents.first.border_style = :bottom_only
+          end
+          
+          
+          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
+end