prawn-git 2.0.1

data/lib/prawn/text/formatted.rb

@@ -0,0 +1,7 @@
+# encoding: utf-8
+
+require_relative "formatted/wrap"
+
+require_relative "formatted/box"
+require_relative "formatted/parser"
+require_relative "formatted/fragment"

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

@@ -0,0 +1,614 @@
+# encoding: utf-8
+
+# text/formatted/rectangle.rb : Implements text boxes with 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
+      # @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.
+      #
+      # == Formatted Text Array
+      #
+      # Formatted text is comprised of an array of hashes, where each hash
+      # defines text and format information. As of the time of writing, the
+      # following hash options are supported:
+      #
+      # <tt>:text</tt>::
+      #     the text to format according to the other hash options
+      # <tt>:styles</tt>::
+      #     an array of styles to apply to this text. Available styles include
+      #     :bold, :italic, :underline, :strikethrough, :subscript, and
+      #     :superscript
+      # <tt>:size</tt>::
+      #     a number denoting the font size to apply to this text
+      # <tt>:character_spacing</tt>::
+      #     a number denoting how much to increase or decrease the default
+      #     spacing between characters
+      # <tt>:font</tt>::
+      #     the name of a font. The name must be an AFM font with the desired
+      #     faces or must be a font that is already registered using
+      #     Prawn::Document#font_families
+      # <tt>:color</tt>::
+      #     anything compatible with Prawn::Graphics::Color#fill_color and
+      #     Prawn::Graphics::Color#stroke_color
+      # <tt>:link</tt>::
+      #     a URL to which to create a link. A clickable link will be created
+      #     to that URL. Note that you must explicitly underline and color using
+      #     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
+      #     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
+      #     prior to and immediately after rendring the text fragment and which
+      #     are passed the fragment as an argument
+      #
+      # == Example
+      #
+      #   formatted_text_box([{ :text => "hello" },
+      #                       { :text => "world",
+      #                         :size => 24,
+      #                         :styles => [:bold, :italic] }])
+      #
+      # == Options
+      #
+      # Accepts the same options as Text::Box with the below exceptions
+      #
+      # == Returns
+      #
+      # Returns a formatted text array representing any text that did not print
+      # under the current settings.
+      #
+      # == Exceptions
+      #
+      # Raises "Bad font family" if no font family is defined for the current font
+      #
+      # Raises <tt>Prawn::Errors::CannotFit</tt> if not wide enough to print
+      # any text
+      #
+      def formatted_text_box(array, options={})
+        Text::Formatted::Box.new(array, options.merge(:document => self)).render
+      end
+
+      # Generally, one would use the Prawn::Text::Formatted#formatted_text_box
+      # convenience method. However, using Text::Formatted::Box.new in
+      # conjunction with #render(:dry_run => true) enables one to do look-ahead
+      # calculations prior to placing text on the page, or to determine how much
+      # vertical space was consumed by the printed text
+      #
+      class Box
+        include Prawn::Text::Formatted::Wrap
+
+        # @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)
+        attr_reader :text
+
+        # True if nothing printed (or, if <tt>dry_run</tt> was
+        # used, nothing would have been successfully printed)
+        def nothing_printed?
+          @nothing_printed
+        end
+
+        # True if everything printed (or, if <tt>dry_run</tt> was
+        # used, everything would have been successfully printed)
+        def everything_printed?
+          @everything_printed
+        end
+
+        # The upper left corner of the text box
+        attr_reader :at
+        # The line height of the last line printed
+        attr_reader :line_height
+        # The height of the ascender of the last line printed
+        attr_reader :ascender
+        # The height of the descender of the last line printed
+        attr_reader :descender
+        # The leading used during printing
+        attr_reader :leading
+
+        def line_gap
+          line_height - (ascender + descender)
+        end
+
+        # See Prawn::Text#text_box for valid options
+        #
+        def initialize(formatted_text, options={})
+          @inked             = false
+          Prawn.verify_options(valid_options, options)
+          options            = options.dup
+
+          self.class.extensions.reverse_each { |e| extend e }
+
+          @overflow          = options[:overflow] || :truncate
+          @disable_wrap_by_char = options[:disable_wrap_by_char]
+
+          self.original_text = formatted_text
+          @text              = nil
+
+          @document          = options[:document]
+          @direction         = options[:direction] || @document.text_direction
+          @fallback_fonts    = options[:fallback_fonts] ||
+                               @document.fallback_fonts
+          @at                = (options[:at] ||
+                               [@document.bounds.left, @document.bounds.top]).dup
+          @width             = options[:width] ||
+                               @document.bounds.right - @at[0]
+          @height            = options[:height] || default_height
+          @align             = options[:align] ||
+                               (@direction == :rtl ? :right : :left)
+          @vertical_align    = options[:valign] || :top
+          @leading           = options[:leading] || @document.default_leading
+          @character_spacing = options[:character_spacing] ||
+                               @document.character_spacing
+          @mode              = options[:mode] || @document.text_rendering_mode
+          @rotate            = options[:rotate] || 0
+          @rotate_around     = options[:rotate_around] || :upper_left
+          @single_line       = options[:single_line]
+          @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
+            # as the bottom of the document bounds, since that
+            # is the maximum we should expand to
+            @height = default_height
+            @overflow = :truncate
+          end
+          @min_font_size = options[:min_font_size] || 5
+          if options[:kerning].nil? then
+            options[:kerning] = @document.default_kerning?
+          end
+          @options = { :kerning => options[:kerning],
+            :size    => options[:size],
+            :style   => options[:style] }
+
+          super(formatted_text, options)
+        end
+
+        # Render text to the document based on the settings defined in initialize.
+        #
+        # In order to facilitate look-ahead calculations, <tt>render</tt> accepts
+        # a <tt>:dry_run => true</tt> option. If provided, then everything is
+        # executed as if rendering, with the exception that nothing is drawn on
+        # the page. Useful for look-ahead computations of height, unprinted text,
+        # etc.
+        #
+        # Returns any text that did not print under the current settings
+        #
+        def render(flags={})
+          unprinted_text = []
+
+          @document.save_font do
+            @document.character_spacing(@character_spacing) do
+              @document.text_rendering_mode(@mode) do
+                process_options
+
+                text = normalized_text(flags)
+
+                @document.font_size(@font_size) do
+                  shrink_to_fit(text) if @overflow == :shrink_to_fit
+                  process_vertical_alignment(text)
+                  @inked = true unless flags[:dry_run]
+                  if @rotate != 0 && @inked
+                    unprinted_text = render_rotated(text)
+                  else
+                    unprinted_text = wrap(text)
+                  end
+                  @inked = false
+                end
+              end
+            end
+          end
+
+          unprinted_text.map do |e|
+            e.merge(:text => @document.font.to_utf8(e[:text]))
+          end
+        end
+
+        # The width available at this point in the box
+        #
+        def available_width
+          @width
+        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
+        end
+
+        # <tt>fragment</tt> is a Prawn::Text::Formatted::Fragment object
+        #
+        def draw_fragment(fragment, accumulated_width=0, line_width=0, word_spacing=0) #:nodoc:
+          case(@align)
+          when :left
+            x = @at[0]
+          when :center
+            x = @at[0] + @width * 0.5 - line_width * 0.5
+          when :right
+            x = @at[0] + @width - line_width
+          when :justify
+            if @direction == :ltr
+              x = @at[0]
+            else
+              x = @at[0] + @width - line_width
+            end
+          end
+
+          x += accumulated_width
+
+          y = @at[1] + @baseline_y
+
+          y += fragment.y_offset
+
+          fragment.left = x
+          fragment.baseline = y
+
+          if @inked
+            draw_fragment_underlays(fragment)
+
+            @document.word_spacing(word_spacing) {
+              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,
+                                              :disable_wrap_by_char,
+                                              :leading, :character_spacing,
+                                              :mode, :single_line,
+                                              :document,
+                                              :direction,
+                                              :fallback_fonts,
+                                              :draw_text_callback]
+        end
+
+        private
+
+        def normalized_text(flags)
+          text = normalize_encoding
+
+          text.each { |t| t.delete(:color) } if flags[:dry_run]
+
+          text
+        end
+
+        def original_text
+          @original_array.collect { |hash| hash.dup }
+        end
+
+        def original_text=(formatted_text)
+          @original_array = formatted_text
+        end
+
+        def normalize_encoding
+          formatted_text = original_text
+
+          unless @fallback_fonts.empty?
+            formatted_text = process_fallback_fonts(formatted_text)
+          end
+
+          formatted_text.each do |hash|
+            if hash[:font]
+              @document.font(hash[:font]) do
+                hash[:text] = @document.font.normalize_encoding(hash[:text])
+              end
+            else
+              hash[:text] = @document.font.normalize_encoding(hash[:text])
+            end
+          end
+
+          formatted_text
+        end
+
+        def process_fallback_fonts(formatted_text)
+          modified_formatted_text = []
+
+          formatted_text.each do |hash|
+            fragments = analyze_glyphs_for_fallback_font_support(hash)
+            modified_formatted_text.concat(fragments)
+          end
+
+          modified_formatted_text
+        end
+
+        def analyze_glyphs_for_fallback_font_support(hash)
+          font_glyph_pairs = []
+
+          original_font = @document.font.family
+          fragment_font = hash[:font] || original_font
+
+          fallback_fonts = @fallback_fonts.dup
+          # always default back to the current font if the glyph is missing from
+          # all fonts
+          fallback_fonts << fragment_font
+
+          @document.save_font do
+            hash[:text].each_char do |char|
+              font_glyph_pairs << [find_font_for_this_glyph(char,
+                                                            fragment_font,
+                                                            fallback_fonts.dup),
+                                   char]
+            end
+          end
+
+          # Don't add a :font to fragments if it wasn't there originally
+          if hash[:font].nil?
+            font_glyph_pairs.each do |pair|
+              pair[0] = nil if pair[0] == original_font
+            end
+          end
+
+          form_fragments_from_like_font_glyph_pairs(font_glyph_pairs, hash)
+        end
+
+        def find_font_for_this_glyph(char, current_font, fallback_fonts)
+          @document.font(current_font)
+          if fallback_fonts.length == 0 || @document.font.glyph_present?(char)
+            current_font
+          else
+            find_font_for_this_glyph(char, fallback_fonts.shift, fallback_fonts)
+          end
+        end
+
+        def form_fragments_from_like_font_glyph_pairs(font_glyph_pairs, hash)
+          fragments = []
+          fragment = nil
+          current_font = nil
+
+          font_glyph_pairs.each do |font, char|
+            if font != current_font || fragments.count == 0
+              current_font = font
+              fragment = hash.dup
+              fragment[:text] = char
+              fragment[:font] = font unless font.nil?
+              fragments << fragment
+            else
+              fragment[:text] += char
+            end
+          end
+
+          fragments
+        end
+
+        def move_baseline_down
+          if @baseline_y == 0
+            @baseline_y  = -@ascender
+          else
+            @baseline_y -= (@line_height + @leading)
+          end
+        end
+
+        # Returns the default height to be used if none is provided or if the
+        # overflow option is set to :expand. If we are in a stretchy bounding
+        # box, assume we can stretch to the bottom of the innermost non-stretchy
+        # box.
+        #
+        def default_height
+          # Find the "frame", the innermost non-stretchy bbox.
+          frame = @document.bounds
+          frame = frame.parent while frame.stretchy? && frame.parent
+
+          @at[1] + @document.bounds.absolute_bottom - frame.absolute_bottom
+        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)
+
+          case @vertical_align
+          when :center
+            @at[1] -= (@height - height + @descender) * 0.5
+          when :bottom
+            @at[1] -= (@height - height)
+          end
+
+          @height = height
+        end
+
+        # Decrease the font size until the text fits or the min font
+        # size is reached
+        def shrink_to_fit(text)
+          loop do
+            if @disable_wrap_by_char && @font_size > @min_font_size
+              begin
+                wrap(text)
+              rescue Errors::CannotFit
+                # Ignore errors while we can still attempt smaller
+                # font sizes.
+              end
+            else
+              wrap(text)
+            end
+
+            break if @everything_printed || @font_size <= @min_font_size
+
+            @font_size = [@font_size - 0.5, @min_font_size].max
+            @document.font_size = @font_size
+          end
+        end
+
+        def process_options
+          # must be performed within a save_font block because
+          # document.process_text_options sets the font
+          @document.process_text_options(@options)
+          @font_size = @options[:size]
+          @kerning   = @options[:kerning]
+        end
+
+        def render_rotated(text)
+          unprinted_text = ''
+
+          case @rotate_around
+          when :center
+            x = @at[0] + @width * 0.5
+            y = @at[1] - @height * 0.5
+          when :upper_right
+            x = @at[0] + @width
+            y = @at[1]
+          when :lower_right
+            x = @at[0] + @width
+            y = @at[1] - @height
+          when :lower_left
+            x = @at[0]
+            y = @at[1] - @height
+          else
+            x = @at[0]
+            y = @at[1]
+          end
+
+          @document.rotate(@rotate, :origin => [x, y]) do
+            unprinted_text = wrap(text)
+          end
+          unprinted_text
+        end
+
+        def draw_fragment_underlays(fragment)
+          fragment.callback_objects.each do |obj|
+            obj.render_behind(fragment) if obj.respond_to?(:render_behind)
+          end
+        end
+
+        def draw_fragment_overlays(fragment)
+          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
+        end
+
+        def draw_fragment_overlay_link(fragment)
+          return unless fragment.link
+          box = fragment.absolute_bounding_box
+          @document.link_annotation(box,
+                                    :Border => [0, 0, 0],
+                                    :A => { :Type => :Action,
+                                            :S => :URI,
+                                            :URI => PDF::Core::LiteralString.new(fragment.link) })
+        end
+
+        def draw_fragment_overlay_anchor(fragment)
+          return unless fragment.anchor
+          box = fragment.absolute_bounding_box
+          @document.link_annotation(box,
+                                    :Border => [0, 0, 0],
+                                    :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)
+          end
+        end
+
+      end
+
+    end
+  end
+end