prawn 0.11.1.pre → 0.11.1

data/lib/prawn/core/page.rb

@@ -6,10 +6,16 @@
 #
 # This is free software. Please see the LICENSE and COPYING files for details.
 #
+
+require 'prawn/document/graphics_state'
+
 module Prawn
   module Core
     class Page #:nodoc:
-      attr_accessor :document, :content, :dictionary, :margins
+
+      include Prawn::Core::Page::GraphicsState
+
+      attr_accessor :document, :content, :dictionary, :margins, :stack
 
       def initialize(document, options={})
         @document = document
@@ -17,12 +23,12 @@ module Prawn
                                            :right   => 36,
                                            :top     => 36,
                                            :bottom  => 36  }
-
+        @stack = Prawn::GraphicStateStack.new(options[:graphic_state])
         if options[:object_id]
           init_from_object(options)
         else
           init_new_page(options)
-        end
+        end 
       end
 
       def layout
@@ -47,10 +53,15 @@ module Prawn
       def stamp_stream(dictionary)
         @stamp_stream     = ""
         @stamp_dictionary = dictionary
+        graphic_stack_size = stack.stack.size
 
-        document.send(:update_colors)
+        document.save_graphics_state
+        document.send(:freeze_stamp_graphics)
         yield if block_given?
-        document.send(:update_colors)
+        
+        until graphic_stack_size == stack.stack.size
+          document.restore_graphics_state
+        end
 
         @stamp_dictionary.data[:Length] = @stamp_stream.length + 1
         @stamp_dictionary << @stamp_stream
@@ -75,6 +86,7 @@ module Prawn
         end
         @content    = document.ref(:Length => 0)
         dictionary.data[:Contents] << document.state.store[@content]
+        document.open_graphics_state
       end
 
       def dictionary
@@ -158,10 +170,11 @@ module Prawn
       end
 
       def init_new_page(options)
-        @size     = options[:size]    ||  "LETTER" 
-        @layout   = options[:layout]  || :portrait         
-        
+        @size     = options[:size]    ||  "LETTER"
+        @layout   = options[:layout]  || :portrait
+
         @content    = document.ref(:Length      => 0)
+        content << "q" << "\n"
         @dictionary = document.ref(:Type        => :Page,
                                    :Parent      => document.state.store.pages,
                                    :MediaBox    => dimensions,
@@ -194,6 +207,7 @@ module Prawn
       end
 
     end
+
   end
 end
 

data/lib/prawn/core/text.rb

@@ -6,8 +6,6 @@
 #
 # This is free software. Please see the LICENSE and COPYING files for details.
 
-ruby_18 { $KCODE="U" }
-
 module Prawn
   module Core
     module Text #:nodoc:
@@ -15,6 +13,9 @@ module Prawn
       # These should be used as a base. Extensions may build on this list
       #
       VALID_OPTIONS = [:kerning, :size, :style]
+      MODES = { :fill => 0, :stroke => 1, :fill_stroke => 2, :invisible => 3,
+                :fill_clip => 4, :stroke_clip => 5, :fill_stroke_clip => 6,
+                :clip => 7 }
 
       attr_reader :skip_encoding
 
@@ -43,35 +44,162 @@ module Prawn
         options[:size] ||= font_size
       end
 
-      # Document wide setting of whether or not to use kerning with text
+      # Retrieve the current default kerning setting.
+      #
       # Defaults to true
-      # Can be overridden using the :kerning text option
       #
       def default_kerning?
         return true if @default_kerning.nil?
         @default_kerning
       end
 
+      # Call with a boolean to set the document-wide kerning setting. This can be
+      # overridden using the :kerning text option when drawing text or a text
+      # box.
+      #
+      #   pdf.default_kerning = false
+      #   pdf.text("hello world")                   # text is not kerned
+      #   pdf.text("hello world", :kerning => true) # text is kerned
+      #
       def default_kerning(boolean)
         @default_kerning = boolean
       end
 
       alias_method :default_kerning=, :default_kerning
 
-      # Document wide setting of leading
+      # Call with no argument to retrieve the current default leading.
+      #
+      # Call with a number to set the document-wide text leading. This can be
+      # overridden using the :leading text option when drawing text or a text
+      # box.
+      #
+      #   pdf.default_leading = 7
+      #   pdf.text("hello world")                # a leading of 7 is used
+      #   pdf.text("hello world", :leading => 0) # a leading of 0 is used
+      #
       # Defaults to 0
-      # Can be overridden using the :leading text option
       #
-      def default_leading?
-        return 0 if @default_leading.nil?
-        @default_leading
+      def default_leading(number=nil)
+        if number.nil?
+          return 0 if @default_leading.nil?
+          @default_leading
+        else
+          @default_leading = number
+        end
       end
 
-      def default_leading(number)
-        @default_leading = number
+      alias_method :default_leading=, :default_leading
+
+      # Call with no argument to retrieve the current text direction.
+      #
+      # Call with a symbol to set the document-wide text direction. This can be
+      # overridden using the :direction text option when drawing text or a text
+      # box.
+      #
+      #   pdf.text_direction = :rtl
+      #   pdf.text("hello world")                     # prints "dlrow olleh"
+      #   pdf.text("hello world", :direction => :ltr) # prints "hello world"
+      #
+      # Valid directions are:
+      #
+      # * :ltr             - left-to-right (default)
+      # * :rtl             - right-to-left
+      #
+      # Side effects:
+      #
+      # * When printing left-to-right, the default text alignment is :left
+      # * When printing right-to-left, the default text alignment is :right
+      #
+      def text_direction(direction=nil)
+        if direction.nil?
+          return :ltr if @text_direction.nil?
+          @text_direction
+        else
+          @text_direction = direction
+        end
       end
 
-      alias_method :default_leading=, :default_leading
+      alias_method :text_direction=, :text_direction
+
+      # Call with no argument to retrieve the current fallback fonts.
+      #
+      # Call with an array of font names. Each name must be the name of an AFM
+      # font or the name that was used to register a family of TTF fonts (see
+      # Prawn::Document#font_families). If present, then each glyph will be
+      # rendered using the first font that includes the glyph, starting with the
+      # current font and then moving through :fallback_fonts from left to right.
+      #
+      # Call with an empty array to turn off fallback fonts
+      #
+      # file = "#{Prawn::BASEDIR}/data/fonts/gkai00mp.ttf"
+      # font_families["Kai"] = {
+      #   :normal => { :file => file, :font => "Kai" }
+      # }
+      # file = "#{Prawn::BASEDIR}/data/fonts/Action Man.dfont"
+      # font_families["Action Man"] = {
+      #   :normal      => { :file => file, :font => "ActionMan" },
+      # }
+      # fallback_fonts ["Times-Roman", "Kai"]
+      # font "Action Man"
+      # text "hello ƒ 你好"
+      # > hello prints in Action Man
+      # > ƒ prints in Times-Roman
+      # > 你好 prints in Kai
+      #
+      # fallback_fonts [] # clears document-wide fallback fonts
+      #
+      # Side effects:
+      #
+      # * Increased overhead when fallback fonts are declared as each glyph is
+      #   checked to see whether it exists in the current font
+      #
+      def fallback_fonts(fallback_fonts=nil)
+        if fallback_fonts.nil?
+          return [] if @fallback_fonts.nil?
+          @fallback_fonts
+        else
+          @fallback_fonts = fallback_fonts
+        end
+      end
+
+      alias_method :fallback_fonts=, :fallback_fonts
+
+      # Call with no argument to retrieve the current text rendering mode.
+      #
+      # Call with a symbol and block to temporarily change the current
+      # text rendering mode.
+      #
+      #   pdf.text_rendering_mode(:stroke) do
+      #     pdf.text("Outlined Text")
+      #   end
+      #
+      # Valid modes are:
+      #
+      # * :fill             - fill text (default)
+      # * :stroke           - stroke text
+      # * :fill_stroke      - fill, then stroke text
+      # * :invisible        - invisible text
+      # * :fill_clip        - fill text then add to path for clipping
+      # * :stroke_clip      - stroke text then add to path for clipping
+      # * :fill_stroke_clip - fill then stroke text, then add to path for clipping
+      # * :clip             - add text to path for clipping
+      #
+      def text_rendering_mode(mode=nil)
+        return @text_rendering_mode || :fill if mode.nil?
+        unless MODES.keys.include?(mode)
+          raise ArgumentError, "mode must be between one of #{MODES.keys.join(', ')} (#{mode})"
+        end
+        original_mode = text_rendering_mode
+        if original_mode == mode
+          yield
+        else
+          @text_rendering_mode = mode
+          add_content "\n#{MODES[mode]} Tr"
+          yield
+          add_content "\n#{MODES[original_mode]} Tr"
+          @text_rendering_mode = original_mode
+        end
+      end
 
       # Increases or decreases the space between characters.
       # For horizontal text, a positive value will increase the space.
@@ -117,7 +245,7 @@ module Prawn
         add_content "\nBT"
 
         if options[:rotate]
-          rad = options[:rotate].to_i * Math::PI / 180
+          rad = options[:rotate].to_f * 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

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

@@ -34,7 +34,7 @@ module Prawn
               raise "Lines must be finalized before calling #space_count"
             end
             @fragments.inject(0) do |sum, fragment|
-              sum + fragment.text.count(" ")
+              sum + fragment.space_count
             end
           end
 
@@ -51,12 +51,18 @@ module Prawn
             if @unfinalized_line
               raise "Lines must be finalized before calling #line"
             end
-            @fragments.collect { |fragment| fragment.text }.join("")
+            @fragments.collect do |fragment|
+              if ruby_18 { true }
+                fragment.text
+              else
+                fragment.text.dup.force_encoding("utf-8")
+              end
+            end.join
           end
 
           def finalize_line
             @unfinalized_line = false
-            remove_trailing_whitespace_from_consumed
+            omit_trailing_whitespace_from_line_width
             @fragments = []
             @consumed.each do |hash|
               text = hash[:text]
@@ -86,6 +92,7 @@ module Prawn
             @max_line_height = 0
             @max_descender = 0
             @max_ascender = 0
+
             @consumed = []
             @fragments = []
           end
@@ -94,10 +101,6 @@ module Prawn
             @unconsumed.length == 0
           end
 
-          def unfinished?
-            @unconsumed.length > 0
-          end
-
           def next_string
             unless @unfinalized_line
               raise "Lines must not be finalized when calling #next_string"
@@ -162,17 +165,22 @@ module Prawn
             end
           end
 
-          def update_last_string(printed, unprinted)
+          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
@@ -185,6 +193,7 @@ module Prawn
           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)
@@ -206,9 +215,24 @@ module Prawn
 
           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)
-              size = @document.font_size * 0.583
+              relative_size = 0.583
+              if size.nil?
+                size = @document.font_size * relative_size
+              else
+                size = size * relative_size
+              end
             end
             if size.nil?
               yield
@@ -229,14 +253,17 @@ module Prawn
             end
           end
 
-          def remove_trailing_whitespace_from_consumed
+          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
-                @consumed.pop
+                # this entire fragment is trailing white space
+                hash[:exclude_trailing_white_space] = true
               else
-                hash[:text].rstrip!
+                # 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

data/lib/prawn/core/text/formatted/line_wrap.rb

@@ -13,7 +13,21 @@ module Prawn
     module Text
       module Formatted #:nodoc:
         
-        class LineWrap < Prawn::Core::Text::LineWrap #:nodoc:
+        class LineWrap #:nodoc:
+
+          # The width of the last wrapped line
+          #
+          def width
+            @accumulated_width || 0
+          end
+
+          # The number of spaces in the last wrapped line
+          attr_reader :space_count
+
+          # Whether this line is the last line in the paragraph
+          def paragraph_finished?
+            @newline_encountered || is_next_string_newline? || @arranger.finished?
+          end
 
           # Work in conjunction with the Prawn::Core::Formatted::Arranger
           # defined in the :arranger option to determine what formatted text
@@ -23,25 +37,15 @@ module Prawn
             initialize_line(options)
 
             while fragment = @arranger.next_string
-              @output = ""
-              preview = @arranger.preview_next_string
-
-              fragment.lstrip! if @line_output.empty? && fragment != "\n"
-              if @line_output.empty? && fragment.empty? && preview == "\n"
-                # this line was just whitespace followed by a newline, which is
-                # equivalent to just a newline
-                @arranger.update_last_string("", "")
-                next
-              end
-              
-              if !add_fragment_to_line(fragment)
-                fragment_finished(fragment, true)
+              @fragment_output = ""
+
+              fragment.lstrip! if first_fragment_on_this_line?(fragment)
+              next if empty_line?(fragment)
+
+              unless apply_font_settings_and_add_fragment_to_line(fragment)
                 break
               end
-              
-              fragment_finished(fragment, preview == "\n" || preview.nil?)
             end
-
             @arranger.finalize_line
             @accumulated_width = @arranger.line_width
             @space_count = @arranger.space_count
@@ -50,76 +54,217 @@ module Prawn
 
           private
 
-          def initialize_line(options)
-            @document = options[:document]
-            @kerning = options[:kerning]
-            @width = options[:width]
-
-            @scan_pattern = scan_pattern
-            @word_division_scan_pattern = word_division_scan_pattern
-
-            @accumulated_width = 0
-            @line_output = ""
+          def first_fragment_on_this_line?(fragment)
+            line_empty? && fragment != "\n"
+          end
 
-            @arranger = options[:arranger]
-            @arranger.initialize_line
+          def empty_line?(fragment)
+            empty = line_empty? && fragment.empty? && is_next_string_newline?
+            @arranger.update_last_string("", "", soft_hyphen) if empty
+            empty
           end
 
-          def fragment_finished(fragment, finished_line)
-            if fragment == "\n"
-              @line_output = "\n" if @line_output.empty?
-            else
-              update_output_based_on_last_fragment(fragment, finished_line)
-              @line_output += @output
-            end
+          def is_next_string_newline?
+            @arranger.preview_next_string == "\n"
           end
 
-          def update_output_based_on_last_fragment(fragment, finished_line)
-            remaining_text = fragment.slice(@output.length..fragment.length)
-            @output.rstrip! if finished_line
-            raise Errors::CannotFit if finished_line && @line_output.empty? &&
-              @output.empty? && !fragment.strip.empty?
-            @arranger.update_last_string(@output, remaining_text)
+          def apply_font_settings_and_add_fragment_to_line(fragment)
+            result = nil
+            @arranger.apply_font_settings do
+              result = add_fragment_to_line(fragment)
+            end
+            result
           end
 
           # returns true iff all text was printed without running into the end of
           # the line
           #
           def add_fragment_to_line(fragment)
-            return true if fragment == ""
-            return false if fragment == "\n"
-            previous_segment = nil
-            fragment.scan(@scan_pattern).each do |segment|
-              @arranger.apply_font_settings do
-                segment_width = @document.width_of(segment, :kerning => @kerning)
+            if fragment == ""
+              true
+            elsif fragment == "\n"
+              @newline_encountered = true
+              false
+            else
+              fragment.scan(scan_pattern).each do |segment|
+                if segment == zero_width_space
+                  segment_width = 0
+                else
+                  segment_width = @document.width_of(segment, :kerning => @kerning)
+                end
 
                 if @accumulated_width + segment_width <= @width
                   @accumulated_width += segment_width
-                  @output += segment
+                  @fragment_output += segment
                 else
-                  end_of_the_line(segment)
+                  end_of_the_line_reached(segment)
+                  fragment_finished(fragment)
                   return false
                 end
               end
-              previous_segment = segment
+
+              fragment_finished(fragment)
+              true
             end
-            true
           end
 
-          # If there is more than one word on the line, then clean up the last
-          # word on the line; otherwise, wrap by character
+          # The pattern used to determine chunks of text to place on a given line
           #
-          def end_of_the_line(segment)
-            if (@line_output + @output) =~ @word_division_scan_pattern
-              if segment =~ new_regexp("^#{hyphen}") &&
-                  @output !~ new_regexp("[#{break_chars}]$")
-                remove_last_output_word
+          def scan_pattern
+            pattern = "[^#{break_chars}]+#{soft_hyphen}|" +
+              "[^#{break_chars}]+#{hyphen}+|" +
+              "[^#{break_chars}]+|" +
+              "[#{whitespace}]+|" +
+              "#{hyphen}+[^#{break_chars}]*|" +
+              "#{soft_hyphen}"
+            new_regexp(pattern)
+          end
+
+          # The pattern used to determine whether any word breaks exist on a
+          # current line, which in turn determines whether character level
+          # word breaking is needed
+          #
+          def word_division_scan_pattern
+            new_regexp("\\s|[#{zero_width_space}#{soft_hyphen}#{hyphen}]")
+          end
+
+          def break_chars
+            "#{whitespace}#{soft_hyphen}#{hyphen}"
+          end
+
+          def whitespace
+            " \\t#{zero_width_space}"
+          end
+
+          def hyphen
+            "-"
+          end
+
+          def soft_hyphen
+            @document.font.normalize_encoding(Prawn::Text::SHY)
+          end
+
+          def zero_width_space
+            @document.font.unicode? ? Prawn::Text::ZWSP : ""
+          end
+
+          def line_empty?
+            @line_empty && @accumulated_width == 0
+          end
+
+          def initialize_line(options)
+            @document = options[:document]
+            @kerning = options[:kerning]
+            @width = options[:width]
+
+            @accumulated_width = 0
+            @line_empty = true
+            @line_contains_more_than_one_word = false
+
+            @arranger = options[:arranger]
+            @arranger.initialize_line
+
+            @newline_encountered = false
+            @line_full = false
+          end
+
+          def fragment_finished(fragment)
+            if fragment == "\n"
+              @newline_encountered = true
+              @line_empty = false
+            else
+              update_output_based_on_last_fragment(fragment, soft_hyphen)
+              update_line_status_based_on_last_output
+              determine_whether_to_pull_preceding_fragment_to_join_this_one(fragment)
+            end
+            remember_this_fragment_for_backward_looking_ops
+          end
+
+          def update_output_based_on_last_fragment(fragment, normalized_soft_hyphen=nil)
+            remaining_text = fragment.slice(@fragment_output.length..fragment.length)
+            raise Errors::CannotFit if line_finished? && line_empty? &&
+              @fragment_output.empty? && !fragment.strip.empty?
+            @arranger.update_last_string(@fragment_output, remaining_text, normalized_soft_hyphen)
+          end
+
+          def determine_whether_to_pull_preceding_fragment_to_join_this_one(current_fragment)
+            if @fragment_output.empty? &&
+                !current_fragment.empty? &&
+                @line_contains_more_than_one_word
+              unless previous_fragment_ended_with_breakable? ||
+                  fragment_begins_with_breakable?(current_fragment)
+                @fragment_output = @previous_fragment_output_without_last_word
+                update_output_based_on_last_fragment(@previous_fragment)
+              end
+            end
+          end
+
+          def remember_this_fragment_for_backward_looking_ops
+            @previous_fragment = @fragment_output.dup
+            pf = @previous_fragment
+            @previous_fragment_ended_with_breakable = pf =~ /[#{break_chars}]$/
+            last_word_length = pf.slice(/[^#{break_chars}]*$/).length
+            @previous_fragment_output_without_last_word = pf.slice(0, pf.length - last_word_length)
+          end
+
+          def previous_fragment_ended_with_breakable?
+            @previous_fragment_ended_with_breakable
+          end
+
+          def fragment_begins_with_breakable?(fragment)
+            fragment =~ /^[#{break_chars}]/
+          end
+
+          def line_finished?
+            @line_full || paragraph_finished?
+          end
+
+          def update_line_status_based_on_last_output
+            @line_contains_more_than_one_word = true if @fragment_output =~ word_division_scan_pattern
+          end
+
+          def end_of_the_line_reached(segment)
+            update_line_status_based_on_last_output
+            wrap_by_char(segment) unless @line_contains_more_than_one_word
+            @line_full = true
+          end
+
+          def wrap_by_char(segment)
+            if @document.font.unicode?
+              segment.unpack("U*").each do |char_int|
+                break unless append_char([char_int].pack("U"))
               end
             else
-              wrap_by_char(segment)
+              segment.each_char do |char|
+                break unless append_char(char)
+              end
             end
           end
 
+          def append_char(char)
+            # kerning doesn't make sense in the context of a single character
+            char_width = @document.width_of(char)
+
+            if @accumulated_width + char_width <= @width
+              @accumulated_width += char_width
+              @fragment_output << char
+              true
+            else
+              false
+            end
+          end
+
+          def new_regexp(pattern)
+            regexp = ruby_19 {
+              Regexp.new(pattern)
+            }
+            regexp = regexp || ruby_18 {
+              lang = @document.font.unicode? ? 'U' : 'N'
+              Regexp.new(pattern, 0, lang)
+            }
+            regexp
+          end
+
         end
       end
     end