prawn 0.4.1 → 0.5.0.1

data/lib/prawn/document/page_geometry.rb

@@ -1,79 +0,0 @@
-# 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

@@ -1,55 +0,0 @@
-# encoding: utf-8
-
-# span.rb : Implements text columns
-#
-# Copyright September 2008, Gregory Brown. All Rights Reserved.
-#
-# This is free software. Please see the LICENSE and COPYING files for details.
-
-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/text.rb

@@ -1,185 +0,0 @@
-# encoding: utf-8
-
-# text.rb : Implements PDF text primitives
-#
-# Copyright May 2008, Gregory Brown. All Rights Reserved.
-#
-# This is free software. Please see the LICENSE and COPYING files for details.
-require "zlib"
-require "prawn/document/text/box"
-require "prawn/document/text/wrapping"
-
-module Prawn
-  class Document
-    module Text
-      include Wrapping
-      
-      # Draws text on the page. If a point is specified via the +:at+
-      # option the text will begin exactly at that point, and the string is
-      # assumed to be pre-formatted to properly fit the page.
-      # 
-      #   pdf.text "Hello World", :at => [100,100]
-      #   pdf.text "Goodbye World", :at => [50,50], :size => 16
-      #
-      # When +:at+ is not specified, Prawn attempts to wrap the text to
-      # fit within your current bounding box (or margin_box if no bounding box
-      # is being used ). Text will flow onto the next page when it reaches
-      # the bottom of the bounding box. Text wrap in Prawn does not re-flow
-      # linebreaks, so if you want fully automated text wrapping, be sure to
-      # remove newlines before attempting to draw your string.  
-      #
-      #   pdf.text "Will be wrapped when it hits the edge of your bounding box"
-      #   pdf.text "This will be centered", :align => :center
-      #   pdf.text "This will be right aligned", :align => :right     
-      #
-      #  Wrapping is done by splitting words by spaces by default.  If your text
-      #  does not contain spaces, you can wrap based on characters instead:
-      #
-      #   pdf.text "This will be wrapped by character", :wrap => :character  
-      #
-      # If your font contains kerning pairs data that Prawn can parse, the 
-      # text will be kerned by default.  You can disable this feature by passing
-      # <tt>:kerning => false</tt>.
-      #
-      # === Text Positioning Details:
-      #
-      # When using the :at parameter, Prawn will position your text by its
-      # baseline, and flow along a single line.
-      #
-      # Otherwise, the text is positioned at font.ascender below the baseline,
-      # making it easy to use this method within bounding boxes and spans.
-      #
-      # == Rotation
-      #
-      # Text can be rotated before it is placed on the canvas by specifying the
-      # :rotate option. Rotation occurs counter-clockwise.
-      #
-      # == Encoding
-      #
-      # Note that strings passed to this function should be encoded as UTF-8.
-      # If you get unexpected characters appearing in your rendered document, 
-      # check this.
-      #
-      # If the current font is a built-in one, although the string must be
-      # encoded as UTF-8, only characters that are available in WinAnsi
-      # are allowed.
-      #
-      # If an empty box is rendered to your PDF instead of the character you 
-      # wanted it usually means the current font doesn't include that character.
-      #
-      def text(text,options={})            
-        # we'll be messing with the strings encoding, don't change the users
-        # original string
-        text = text.to_s.dup                      
-        
-        save_font do
-          options = text_options.merge(options)
-          process_text_options(options) 
-           
-          font.normalize_encoding(text) unless @skip_encoding        
-
-          if options[:at]                
-            x,y = translate(options[:at])            
-            font_size(options[:size]) { add_text_content(text,x,y,options) }
-          else
-            if options[:rotate]
-              raise ArgumentError, "Rotated text may only be used with :at" 
-            end
-            wrapped_text(text,options)
-          end         
-        end
-      end 
-                          
-      # A hash of configuration options, to be used globally by text().
-      # 
-      #   pdf.text_options.update(:size => 16, :align => :right)   
-      #   pdf.text "Hello World" #=> Size 16 w. right alignment
-      #
-      def text_options
-        @text_options ||= {}
-      end 
-                       
-      private 
-      
-      def process_text_options(options)
-        Prawn.verify_options [:style, :kerning, :size, :at, :wrap, 
-                              :spacing, :align, :rotate, :final_gap ], options                               
-        
-        if options[:style]  
-          raise "Bad font family" unless font.family
-          font(font.family,:style => options[:style])
-        end
-
-        unless options.key?(:kerning)
-          options[:kerning] = font.has_kerning_data?
-        end                     
-
-        options[:size] ||= font_size
-     end
-
-      def move_text_position(dy)   
-         bottom = @bounding_box.stretchy? ? @margin_box.absolute_bottom :
-                                            @bounding_box.absolute_bottom
-         start_new_page if (y - dy) < bottom
-         
-         self.y -= dy       
-      end
-
-      def wrapped_text(text,options) 
-        options[:align] ||= :left      
-
-        font_size(options[:size]) do
-          text = naive_wrap(text, bounds.right, font_size, 
-            :kerning => options[:kerning], :mode => options[:wrap]) 
-
-          lines = text.lines.to_a
-          last_gap_before = options.fetch(:final_gap, true) ? lines.length : lines.length-1
-                                                       
-          lines.each_with_index do |e,i|         
-            move_text_position(font.ascender)
-                           
-            line_width = font.width_of(e, :kerning => options[:kerning])
-            case(options[:align]) 
-            when :left
-              x = @bounding_box.absolute_left
-            when :center
-              x = @bounding_box.absolute_left + 
-                (@bounding_box.width - line_width) / 2.0
-            when :right
-              x = @bounding_box.absolute_right - line_width 
-            end
-                               
-            add_text_content(e,x,y,options)
-            
-            if i < last_gap_before
-              move_text_position(font.line_gap - font.descender)
-              move_text_position(options[:spacing]) if options[:spacing]
-            end
-          end 
-        end
-      end  
-
-      def add_text_content(text, x, y, options)
-        chunks = font.encode_text(text,options)
-
-        add_content "\nBT"
-        if options[:rotate]
-          rad = options[:rotate].to_i * Math::PI / 180
-          arr = [ Math.cos(rad), Math.sin(rad), -Math.sin(rad), Math.cos(rad), x, y ]
-          add_content "%.3f %.3f %.3f %.3f %.3f %.3f Tm" % arr
-        else
-          add_content "#{x} #{y} Td"
-        end
-
-        chunks.each do |(subset, string)|
-          font.add_to_current_page(subset)
-          add_content "/#{font.identifier_for(subset)} #{font_size} Tf"
-
-          operation = options[:kerning] && string.is_a?(Array) ? "TJ" : "Tj"
-          add_content Prawn::PdfObject(string, true) << " " << operation
-        end
-        add_content "ET\n"
-      end
-    end
-  end
-end

data/lib/prawn/document/text/box.rb

@@ -1,76 +0,0 @@
-# encoding: utf-8
-
-# text/box.rb : Implements simple text boxes
-#
-# Copyright September 2008, Gregory Brown. All Rights Reserved.
-#
-# This is free software. Please see the LICENSE and COPYING files for details.
-
-module Prawn
-  class Document
-    
-    # Defines an invisible rectangle which you can flow text in. When the
-    # text overflows the box, you can either display :ellipses, :truncate
-    # the text, or allow it to :overflow the bottom boundary.
-    #
-    #   text_box "Oh hai text box. " * 200, 
-    #     :width    => 300, :height => font.height * 5,
-    #     :overflow => :ellipses, 
-    #     :at       => [100,bounds.top]
-    #
-    def text_box(text,options)
-      Text::Box.new(text, options.merge(:for => self)).render
-    end
-    
-    module Text 
-      class Box #:nodoc:
-        def initialize(text,options={})
-          @document  = options[:for]
-          @text      = text
-          @at        = options[:at] || [0, @document.y - @document.bounds.absolute_bottom]
-          @width     = options[:width] || @document.bounds.width
-          @height    = options[:height]
-          @overflow  = options[:overflow] || :truncate
-        end
-        
-        def render
-          x,y = @at
-          
-          unless @overflow == :expand
-            original_y = @document.y
-            fit_text_to_box
-          end
-          
-          @document.bounding_box([x,@document.bounds.top], 
-            :width => @width, :height => @document.bounds.height) do
-            @document.y = @document.bounds.absolute_bottom + y 
-            @document.text @text
-          end
-          
-          unless @overflow == :expand
-            @document.y = y + @document.bounds.absolute_bottom - @height  
-          end        
-        end
-        
-        private
-        
-        def fit_text_to_box
-          text = @document.naive_wrap(@text, @width, @document.font_size)
-            
-          max_lines = (@height / @document.font.height).floor
-
-          lines = text.lines.to_a
-          
-          if lines.length > max_lines
-            @text = lines[0...max_lines].join
-            case(@overflow)
-            when :ellipses
-              @text[-3..-1] = "..."
-            end
-          end 
-        end
-        
-      end
-    end
-  end
-end

data/lib/prawn/document/text/wrapping.rb

@@ -1,59 +0,0 @@
-# encoding: utf-8
-
-# wrapping.rb : Implementation of naive text wrap
-#
-# Copyright May 2008, Michael Daines. All Rights Reserved.
-#
-# This is free software. Please see the LICENSE and COPYING files for details.
-module Prawn
-  class Document
-    module Text
-      module Wrapping #:nodoc:                
-        ruby_18 { $KCODE="U" }
-        
-        # Gets height of text in PDF points at current font size.
-        # Text +:line_width+ must be specified in PDF points.
-        #
-        # If using an AFM, string *must* be encoded as WinAnsi
-        # (Use normalize_encoding to convert)
-        #
-        def height_of(string, line_width, size=font_size)
-          string = naive_wrap(string, line_width, size)
-          string.lines.to_a.length * font.height_at(size)
-        end
-
-        # TODO: Replace with TeX optimal algorithm
-        def naive_wrap(string, line_width, font_size, options = {})
-          scan_pattern = options[:mode] == :character ? /./ : /\S+|\s+/                                    
-          
-          output = ""                
-          string.lines.each do |line| 
-            accumulated_width = 0        
-            segments = line.scan(scan_pattern)
-                                          
-            segments.each do |segment|    
-              segment_width = font.width_of(segment, :size => font_size, :kerning => options[:kerning]) 
-        
-              if (accumulated_width + segment_width).round > line_width.round
-                output = "#{output.sub(/[ \t]*\n?(\n*)\z/, "\n\\1")}"
-                
-                if segment =~ /\s/           
-                  accumulated_width = 0
-                else
-                  output << segment
-                  accumulated_width = segment_width
-                end
-              else                           
-                output << segment
-                accumulated_width += segment_width
-              end
-            end    
-          end
-
-          output
-        end
-        
-      end  
-    end
-  end
-end