prawn-layout 0.2.1 → 0.3.1

data/vendor/prawn-core/lib/prawn/document/snapshot.rb

@@ -0,0 +1,71 @@
+# encoding: utf-8
+
+# snapshot.rb : Implements transactional rendering for Prawn
+#
+# Copyright August 2008, Brad Ediger.  All Rights Reserved.
+#
+# This is free software. Please see the LICENSE and COPYING files for details.
+require 'delegate'
+
+module Prawn
+  class Document
+    module Snapshot
+
+      RollbackTransaction = Class.new(StandardError)
+
+      # Call this within a +transaction+ block to roll back the transaction and
+      # prevent any of its data from being rendered. You must reset the
+      # y-position yourself if you have performed any drawing operations that
+      # modify it.
+      def rollback
+        raise RollbackTransaction
+      end
+
+      # Run a block of drawing operations, to be completed atomically. If
+      # +rollback+ is called or a RollbackTransaction exception is raised
+      # inside the block, all actions taken inside the block will be rolled
+      # back (with the exception of y-position, which you must restore
+      # yourself). 
+      #
+      # Returns true on success, or false if the transaction was rolled back.
+      def transaction
+        snap = take_snapshot
+        yield
+        true
+      rescue RollbackTransaction
+        restore_snapshot(snap)
+        false
+      end
+
+      private
+      
+      # Takes a current snapshot of the document's state, sufficient to
+      # reconstruct it after it was amended.
+      def take_snapshot
+        {:page_content    => Marshal.load(Marshal.dump(page_content)),
+         :current_page    => Marshal.load(Marshal.dump(current_page)),
+         :page_kids       => @store.pages.data[:Kids].map{|kid| kid.identifier},
+         :dests           => Marshal.load(Marshal.dump(names.data[:Dests]))}
+      end
+
+      # Rolls the page state back to the state of the given snapshot.
+      def restore_snapshot(shot)
+        # Because these objects are referenced by identifier from the Pages
+        # dictionary, we can't just restore them over the current refs in
+        # page_content and current_page. We have to restore them over the old
+        # ones.
+        @page_content = shot[:page_content].identifier
+        page_content.replace shot[:page_content]
+
+        @current_page = shot[:current_page].identifier
+        current_page.replace shot[:current_page]
+
+        @store.pages.data[:Kids] = shot[:page_kids].map{|id| @store[id]}
+        @store.pages.data[:Count] = shot[:page_kids].size
+
+        names.data[:Dests] = shot[:dests]
+      end
+
+    end
+  end
+end

data/vendor/prawn-core/lib/prawn/document/span.rb

@@ -0,0 +1,55 @@
+# 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/vendor/prawn-core/lib/prawn/document/text.rb

@@ -0,0 +1,184 @@
+# 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 the
+      # left-most edge of its baseline, and flow along a single line.  (This
+      # means that :align will not work)
+      # 
+      #
+      # 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 with a given angle. 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]                
+
+            if options[:align]
+              raise ArgumentError, "The :align option does not work with :at" 
+            end
+
+            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 
+
+      private 
+                        
+      def process_text_options(options)
+        Prawn.verify_options [:style, :kerning, :size, :at, :wrap, 
+                              :leading, :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
+
+         @bounding_box.move_past_bottom 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.width, 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 = width_of(e, :kerning => options[:kerning])
+            case(options[:align]) 
+            when :left
+              x = @bounding_box.left_side
+            when :center
+              x = @bounding_box.left_side +
+                (@bounding_box.width - line_width) / 2.0
+            when :right
+              x = @bounding_box.right_side - 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[:leading]) if options[:leading]
+            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/vendor/prawn-core/lib/prawn/document/text/box.rb

@@ -0,0 +1,90 @@
+# 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 with :expand.
+    #
+    #   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 
+      # FIXME: requires documentation
+      #
+      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
+
+        attr_reader :text, :width, :height, :overflow
+        
+        def render
+          x,y = @at
+          
+          if @overflow == :expand
+            @text = naive_wrap_text
+          else
+            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        
+
+          @excess_text
+        end
+        
+        private        
+        
+        def fit_text_to_box
+          text = naive_wrap_text
+            
+          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] = "..." if @text.size > 3
+            end
+            @excess_text = @document.naive_unwrap(lines[max_lines..-1].join)
+          else
+            @excess_text = ""
+          end 
+        end
+        
+        def naive_wrap_text
+          @document.naive_wrap(@text, @width, @document.font_size)
+        end
+      end
+    end
+  end
+end

data/vendor/prawn-core/lib/prawn/document/text/wrapping.rb

@@ -0,0 +1,62 @@
+# 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 = 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
+        
+        def naive_unwrap(string)
+          string.gsub(/(\S)\n/, '\1 ')
+        end
+      end  
+    end
+  end
+end