prawn-layout 0.3.2 → 0.7.1

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

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

@@ -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/vendor/prawn-core/lib/prawn/document/text.rb

@@ -1,184 +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 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

@@ -1,90 +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 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

@@ -1,62 +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 = 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