prawn 0.11.1 → 0.15.0

data/lib/prawn/text/formatted/arranger.rb

@@ -0,0 +1,290 @@
+# encoding: utf-8
+
+# core/text/formatted/arranger.rb : Implements a data structure for 2-stage
+#                                   processing of lines of formatted text
+#
+# Copyright February 2010, Daniel Nelson. All Rights Reserved.
+#
+# This is free software. Please see the LICENSE and COPYING files for details.
+
+module Prawn
+  module Text
+    module Formatted #:nodoc:
+
+      # @private
+      
+      class Arranger #:nodoc:
+        attr_reader :max_line_height
+        attr_reader :max_descender
+        attr_reader :max_ascender
+        attr_accessor :consumed
+
+        # The following present only for testing purposes
+        attr_reader :unconsumed
+        attr_reader :fragments
+        attr_reader :current_format_state
+
+        def initialize(document, options={})
+          @document = document
+          @fragments = []
+          @unconsumed = []
+          @kerning = options[:kerning]
+        end
+
+        def space_count
+          if @unfinalized_line
+            raise "Lines must be finalized before calling #space_count"
+          end
+          @fragments.inject(0) do |sum, fragment|
+            sum + fragment.space_count
+          end
+        end
+
+        def line_width
+          if @unfinalized_line
+            raise "Lines must be finalized before calling #line_width"
+          end
+          @fragments.inject(0) do |sum, fragment|
+            sum + fragment.width
+          end
+        end
+
+        def line
+          if @unfinalized_line
+            raise "Lines must be finalized before calling #line"
+          end
+          @fragments.collect do |fragment|
+            fragment.text.dup.force_encoding(::Encoding::UTF_8)
+          end.join
+        end
+
+        def finalize_line
+          @unfinalized_line = false
+          omit_trailing_whitespace_from_line_width
+          @fragments = []
+          @consumed.each do |hash|
+            text = hash[:text]
+            format_state = hash.dup
+            format_state.delete(:text)
+            fragment = Prawn::Text::Formatted::Fragment.new(text,
+                                                            format_state,
+                                                            @document)
+            @fragments << fragment
+            set_fragment_measurements(fragment)
+            set_line_measurement_maximums(fragment)
+          end
+        end
+
+        def format_array=(array)
+          initialize_line
+          @unconsumed = []
+          array.each do |hash|
+            hash[:text].scan(/[^\n]+|\n/) do |line|
+              @unconsumed << hash.merge(:text => line)
+            end
+          end
+        end
+
+        def initialize_line
+          @unfinalized_line = true
+          @max_line_height = 0
+          @max_descender = 0
+          @max_ascender = 0
+
+          @consumed = []
+          @fragments = []
+        end
+
+        def finished?
+          @unconsumed.length == 0
+        end
+
+        def next_string
+          unless @unfinalized_line
+            raise "Lines must not be finalized when calling #next_string"
+          end
+          hash = @unconsumed.shift
+          if hash.nil?
+            nil
+          else
+            @consumed << hash.dup
+            @current_format_state = hash.dup
+            @current_format_state.delete(:text)
+            hash[:text]
+          end
+        end
+
+        def preview_next_string
+          hash = @unconsumed.first
+          if hash.nil? then nil
+          else hash[:text]
+          end
+        end
+
+        def apply_color_and_font_settings(fragment, &block)
+          if fragment.color
+            original_fill_color = @document.fill_color
+            original_stroke_color = @document.stroke_color
+            @document.fill_color(*fragment.color)
+            @document.stroke_color(*fragment.color)
+            apply_font_settings(fragment, &block)
+            @document.stroke_color = original_stroke_color
+            @document.fill_color = original_fill_color
+          else
+            apply_font_settings(fragment, &block)
+          end
+        end
+
+        def apply_font_settings(fragment=nil, &block)
+          if fragment.nil?
+            font = current_format_state[:font]
+            size = current_format_state[:size]
+            character_spacing = current_format_state[:character_spacing] ||
+                                @document.character_spacing
+            styles = current_format_state[:styles]
+            font_style = font_style(styles)
+          else
+            font = fragment.font
+            size = fragment.size
+            character_spacing = fragment.character_spacing
+            styles = fragment.styles
+            font_style = font_style(styles)
+          end
+
+          @document.character_spacing(character_spacing) do
+            if font || font_style != :normal
+              raise "Bad font family" unless @document.font.family
+              @document.font(font || @document.font.family, :style => font_style) do
+                apply_font_size(size, styles, &block)
+              end
+            else
+              apply_font_size(size, styles, &block)
+            end
+          end
+        end
+
+        def update_last_string(printed, unprinted, normalized_soft_hyphen=nil)
+          return if printed.nil?
+          if printed.empty?
+            @consumed.pop
+          else
+            @consumed.last[:text] = printed
+            if normalized_soft_hyphen
+              @consumed.last[:normalized_soft_hyphen] = normalized_soft_hyphen
+            end
+          end
+
+          unless unprinted.empty?
+            @unconsumed.unshift(@current_format_state.merge(:text => unprinted))
+          end
+
+          load_previous_format_state if printed.empty?
+        end
+
+        def retrieve_fragment
+          if @unfinalized_line
+            raise "Lines must be finalized before fragments can be retrieved"
+          end
+          @fragments.shift
+        end
+
+        def repack_unretrieved
+          new_unconsumed = []
+          while fragment = retrieve_fragment
+            fragment.include_trailing_white_space!
+            new_unconsumed << fragment.format_state.merge(:text => fragment.text)
+          end
+          @unconsumed = new_unconsumed.concat(@unconsumed)
+        end
+
+        def font_style(styles)
+          if styles.nil?
+            :normal
+          elsif styles.include?(:bold) && styles.include?(:italic)
+            :bold_italic
+          elsif styles.include?(:bold)
+            :bold
+          elsif styles.include?(:italic)
+            :italic
+          else
+            :normal
+          end
+        end
+
+        private
+
+        def load_previous_format_state
+          if @consumed.empty?
+            @current_format_state = {}
+          else
+            hash = @consumed.last
+            @current_format_state = hash.dup
+            @current_format_state.delete(:text)
+          end
+        end
+
+        def apply_font_size(size, styles)
+          if subscript?(styles) || superscript?(styles)
+            relative_size = 0.583
+            if size.nil?
+              size = @document.font_size * relative_size
+            else
+              size = size * relative_size
+            end
+          end
+          if size.nil?
+            yield
+          else
+            @document.font_size(size) { yield }
+          end
+        end
+
+        def subscript?(styles)
+          if styles.nil? then false
+          else styles.include?(:subscript)
+          end
+        end
+
+        def superscript?(styles)
+          if styles.nil? then false
+          else styles.include?(:superscript)
+          end
+        end
+
+        def omit_trailing_whitespace_from_line_width
+          @consumed.reverse_each do |hash|
+            if hash[:text] == "\n"
+              break
+            elsif hash[:text].strip.empty? && @consumed.length > 1
+              # this entire fragment is trailing white space
+              hash[:exclude_trailing_white_space] = true
+            else
+              # this fragment contains the first non-white space we have
+              # encountered since the end of the line
+              hash[:exclude_trailing_white_space] = true
+              break
+            end
+          end
+        end
+
+        def set_fragment_measurements(fragment)
+          apply_font_settings(fragment) do
+            fragment.width = @document.width_of(fragment.text,
+                                                :kerning => @kerning)
+            fragment.line_height = @document.font.height
+            fragment.descender = @document.font.descender
+            fragment.ascender = @document.font.ascender
+          end
+        end
+
+        def set_line_measurement_maximums(fragment)
+          @max_line_height = [defined?(@max_line_height) && @max_line_height, fragment.line_height].compact.max
+          @max_descender = [defined?(@max_descender) && @max_descender, fragment.descender].compact.max
+          @max_ascender = [defined?(@max_ascender) && @max_ascender, fragment.ascender].compact.max
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -10,7 +10,8 @@
 module Prawn
   module Text
     module Formatted
-
+      # @group Stable API
+      
       # Draws the requested formatted text into a box. When the text overflows
       # the rectangle shrink to fit or truncate the text. Text boxes are
       # independent of the document y position.
@@ -45,10 +46,19 @@ module Prawn
       #     the appropriate tags if you which to draw attention to the link
       # <tt>:anchor</tt>::
       #     a destination that has already been or will be registered using
-      #     Prawn::Core::Destinations#add_dest. A clickable link will be
+      #     PDF::Core::Destinations#add_dest. A clickable link will be
       #     created to that destination. Note that you must explicitly underline
       #     and color using the appropriate tags if you which to draw attention
       #     to the link
+      # <tt>:local</tt>::
+      #     a file or application to be opened locally. A clickable link will be
+      #     created to the provided local file or application. If the file is
+      #     another PDF, it will be opened in a new window. Note that you must
+      #     explicitly underline and color using the appropriate tags if you which
+      #     to draw attention to the link
+      # <tt>:draw_text_callback</tt>:
+      #     if provided, this Proc will be called instead of #draw_text! once
+      #     per fragment for every low-level addition of text to the page.
       # <tt>:callback</tt>::
       #     an object (or array of such objects) with two methods:
       #     #render_behind and #render_in_front, which are called immediately
@@ -89,20 +99,9 @@ module Prawn
       # vertical space was consumed by the printed text
       #
       class Box
-        include Prawn::Core::Text::Formatted::Wrap
+        include Prawn::Text::Formatted::Wrap
 
-        def valid_options
-          Prawn::Core::Text::VALID_OPTIONS + [:at, :height, :width,
-                                              :align, :valign,
-                                              :rotate, :rotate_around,
-                                              :overflow, :min_font_size,
-                                              :leading, :character_spacing,
-                                              :mode, :single_line,
-                                              :skip_encoding,
-                                              :document,
-                                              :direction,
-                                              :fallback_fonts]
-        end
+        # @group Experimental API
 
         # The text that was successfully printed (or, if <tt>dry_run</tt> was
         # used, the text that would have been successfully printed)
@@ -135,42 +134,6 @@ module Prawn
           line_height - (ascender + descender)
         end
 
-        #
-        # Example (see Prawn::Text::Core::Formatted::Wrap for what is required
-        # of the wrap method if you want to override the default wrapping
-        # algorithm):
-        # 
-        #
-        #   module MyWrap
-        #
-        #     def wrap(array)
-        #       initialize_wrap([{ :text => 'all your base are belong to us' }])
-        #       @line_wrap.wrap_line(:document => @document,
-        #                            :kerning => @kerning,
-        #                            :width => 10000,
-        #                            :arranger => @arranger)
-        #       fragment = @arranger.retrieve_fragment
-        #       format_and_draw_fragment(fragment, 0, @line_wrap.width, 0)
-        #       []
-        #     end
-        #
-        #   end
-        #
-        #   Prawn::Text::Formatted::Box.extensions << MyWrap
-        #
-        #   box = Prawn::Text::Formatted::Box.new('hello world')
-        #   box.render('why can't I print anything other than' +
-        #              '"all your base are belong to us"?')
-        #
-        #
-        def self.extensions
-          @extensions ||= []
-        end
-
-        def self.inherited(base) #:nodoc:
-          extensions.each { |e| base.extensions << e }
-        end
-
         # See Prawn::Text#text_box for valid options
         #
         def initialize(formatted_text, options={})
@@ -205,6 +168,12 @@ module Prawn
           @rotate_around     = options[:rotate_around] || :upper_left
           @single_line       = options[:single_line]
           @skip_encoding     = options[:skip_encoding] || @document.skip_encoding
+          @draw_text_callback = options[:draw_text_callback]
+
+          # if the text rendering mode is :unknown, force it back to :fill
+          if @mode == :unknown
+            @mode = :fill
+          end
 
           if @overflow == :expand
             # if set to expand, then we simply set the bottom
@@ -273,7 +242,7 @@ module Prawn
         end
 
         # The height actually used during the previous <tt>render</tt>
-        # 
+        #
         def height
           return 0 if @baseline_y.nil? || @descender.nil?
           (@baseline_y - @descender).abs
@@ -310,14 +279,71 @@ module Prawn
             draw_fragment_underlays(fragment)
 
             @document.word_spacing(word_spacing) {
-              @document.draw_text!(fragment.text, :at => [x, y],
-                                   :kerning => @kerning)
+              if @draw_text_callback
+                @draw_text_callback.call(fragment.text, :at => [x, y],
+                                         :kerning => @kerning)
+              else
+                @document.draw_text!(fragment.text, :at => [x, y],
+                                     :kerning => @kerning)
+              end
             }
 
             draw_fragment_overlays(fragment)
           end
         end
 
+        # @group Extension API
+        
+        # Example (see Prawn::Text::Core::Formatted::Wrap for what is required
+        # of the wrap method if you want to override the default wrapping
+        # algorithm):
+        #
+        #
+        #   module MyWrap
+        #
+        #     def wrap(array)
+        #       initialize_wrap([{ :text => 'all your base are belong to us' }])
+        #       @line_wrap.wrap_line(:document => @document,
+        #                            :kerning => @kerning,
+        #                            :width => 10000,
+        #                            :arranger => @arranger)
+        #       fragment = @arranger.retrieve_fragment
+        #       format_and_draw_fragment(fragment, 0, @line_wrap.width, 0)
+        #       []
+        #     end
+        #
+        #   end
+        #
+        #   Prawn::Text::Formatted::Box.extensions << MyWrap
+        #
+        #   box = Prawn::Text::Formatted::Box.new('hello world')
+        #   box.render('why can't I print anything other than' +
+        #              '"all your base are belong to us"?')
+        #
+        #
+        def self.extensions
+          @extensions ||= []
+        end
+
+        # @private
+        def self.inherited(base)
+          extensions.each { |e| base.extensions << e }
+        end
+
+        def valid_options
+          PDF::Core::Text::VALID_OPTIONS + [:at, :height, :width,
+                                              :align, :valign,
+                                              :rotate, :rotate_around,
+                                              :overflow, :min_font_size,
+                                              :leading, :character_spacing,
+                                              :mode, :single_line,
+                                              :skip_encoding,
+                                              :document,
+                                              :direction,
+                                              :fallback_fonts,
+                                              :draw_text_callback]
+        end
+
         private
 
         def original_text
@@ -371,8 +397,7 @@ module Prawn
           # all fonts
           fallback_fonts << fragment_font
 
-          hash[:text].unpack("U*").each do |char_int|
-            char = [char_int].pack("U")
+          hash[:text].each_char do |char|
             @document.font(fragment_font)
             font_glyph_pairs << [find_font_for_this_glyph(char,
                                                           @document.font.family,
@@ -437,6 +462,13 @@ module Prawn
         end
 
         def process_vertical_alignment(text)
+          # The vertical alignment must only be done once per text box, but
+          # we need to wait until render() is called so that the fonts are set
+          # up properly for wrapping. So guard with a boolean to ensure this is
+          # only run once.
+          return if defined?(@vertical_alignment_processed) && @vertical_alignment_processed
+          @vertical_alignment_processed = true
+
           return if @vertical_align == :top
           wrap(text)
 
@@ -444,7 +476,7 @@ module Prawn
           when :center
             @at[1] = @at[1] - (@height - height) * 0.5
           when :bottom
-            @at[1] = @at[1] - (@height - height)
+            @at[1] = @at[1] - (@height - height) + @descender
           end
           @height = height
         end
@@ -505,6 +537,7 @@ module Prawn
           draw_fragment_overlay_styles(fragment)
           draw_fragment_overlay_link(fragment)
           draw_fragment_overlay_anchor(fragment)
+          draw_fragment_overlay_local(fragment)
           fragment.callback_objects.each do |obj|
             obj.render_in_front(fragment) if obj.respond_to?(:render_in_front)
           end
@@ -517,7 +550,7 @@ module Prawn
                                     :Border => [0, 0, 0],
                                     :A => { :Type => :Action,
                                             :S => :URI,
-                                            :URI => Prawn::Core::LiteralString.new(fragment.link) })
+                                            :URI => PDF::Core::LiteralString.new(fragment.link) })
         end
 
         def draw_fragment_overlay_anchor(fragment)
@@ -528,12 +561,23 @@ module Prawn
                                     :Dest => fragment.anchor)
         end
 
+        def draw_fragment_overlay_local(fragment)
+          return unless fragment.local
+          box = fragment.absolute_bounding_box
+          @document.link_annotation(box,
+                                    :Border => [0, 0, 0],
+                                    :A => { :Type => :Action,
+                                            :S => :Launch,
+                                            :F => PDF::Core::LiteralString.new(fragment.local),
+                                            :NewWindow => true })
+        end
+
         def draw_fragment_overlay_styles(fragment)
           underline = fragment.styles.include?(:underline)
           if underline
             @document.stroke_line(fragment.underline_points)
           end
-          
+
           strikethrough = fragment.styles.include?(:strikethrough)
           if strikethrough
             @document.stroke_line(fragment.strikethrough_points)

data/lib/prawn/text/formatted/fragment.rb

@@ -10,39 +10,27 @@ module Prawn
   module Text
     module Formatted
 
+
       # Prawn::Text::Formatted::Fragment is a state store for a formatted text
       # fragment. It does not render anything.
       #
+      # @private
       class Fragment
 
-        attr_reader :format_state
+        attr_reader :format_state, :text
         attr_writer :width
         attr_accessor :line_height, :descender, :ascender
         attr_accessor :word_spacing, :left, :baseline
 
         def initialize(text, format_state, document)
-          @text = text
           @format_state = format_state
           @document = document
           @word_spacing = 0
-        end
 
-        def text
-          string = strip_zero_width_spaces(@text)
-          if exclude_trailing_white_space?
-            string = string.rstrip
-            string = process_soft_hyphens(string)
-          end
-          case direction
-          when :rtl
-            if ruby_18 { true }
-              string.scan(/./mu).reverse.join
-            else
-              string.reverse
-            end
-          else
-            string
-          end
+          # keep the original value of "text", so we can reinitialize @text if formatting parameters
+          #   like text direction are changed
+          @original_text = text
+          @text = process_text(@original_text)
         end
 
         def width
@@ -105,6 +93,10 @@ module Prawn
           @format_state[:anchor]
         end
 
+        def local
+          @format_state[:local]
+        end
+
         def color
           @format_state[:color]
         end
@@ -127,16 +119,19 @@ module Prawn
         end
 
         def default_direction=(direction)
-          @format_state[:direction] = direction unless @format_state[:direction]
+          unless @format_state[:direction]
+            @format_state[:direction] = direction
+            @text = process_text(@original_text)
+          end
         end
 
         def include_trailing_white_space!
           @format_state.delete(:exclude_trailing_white_space)
+          @text = process_text(@original_text)
         end
 
         def space_count
-          string = exclude_trailing_white_space? ? @text.rstrip : @text
-          string.count(" ")
+          @text.count(" ")
         end
 
         def callback_objects
@@ -212,6 +207,19 @@ module Prawn
 
         private
 
+        def process_text(text)
+          string = strip_zero_width_spaces(text)
+          if exclude_trailing_white_space?
+            string = process_soft_hyphens(string.rstrip)
+          end
+          case direction
+          when :rtl
+            string.reverse
+          else
+            string
+          end
+        end
+
         def exclude_trailing_white_space?
           @format_state[:exclude_trailing_white_space]
         end
@@ -222,6 +230,9 @@ module Prawn
 
         def process_soft_hyphens(string)
           if string.length > 0 && normalized_soft_hyphen
+            if string.encoding != normalized_soft_hyphen.encoding
+              string.force_encoding(normalized_soft_hyphen.encoding)
+            end
             string[0..-2].gsub(normalized_soft_hyphen, "") + string[-1..-1]
           else
             string
@@ -229,7 +240,7 @@ module Prawn
         end
 
         def strip_zero_width_spaces(string)
-          if !"".respond_to?(:encoding) || string.encoding.to_s == "UTF-8"
+          if string.encoding == ::Encoding::UTF_8
             string.gsub(Prawn::Text::ZWSP, "")
           else
             string