nurettin-prawn 1.0.0.rc1

data/lib/prawn/core/text.rb

@@ -0,0 +1,268 @@
+# encoding: utf-8
+
+# prawn/core/text.rb : Implements low level text helpers for Prawn
+#
+# Copyright January 2010, Daniel Nelson.  All Rights Reserved.
+#
+# This is free software. Please see the LICENSE and COPYING files for details.
+
+module Prawn
+  module Core
+    module Text #:nodoc:
+
+      # 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
+
+      # Low level text placement method. All font and size alterations
+      # should already be set
+      #
+      def draw_text!(text, options)
+        x,y = map_to_absolute(options[:at])
+        add_text_content(text,x,y,options)
+      end
+
+      # Low level call to set the current font style and extract text options from
+      # an options hash. Should be called from within a save_font block
+      #
+      def process_text_options(options)
+        if options[:style]
+          raise "Bad font family" unless font.family
+          font(font.family, :style => options[:style])
+        end
+
+        # must compare against false to keep kerning on as default
+        unless options[:kerning] == false
+          options[:kerning] = font.has_kerning_data?
+        end
+
+        options[:size] ||= font_size
+      end
+
+      # Retrieve the current default kerning setting.
+      #
+      # Defaults to true
+      #
+      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
+
+      # 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
+      #
+      def default_leading(number=nil)
+        if number.nil?
+          return 0 if @default_leading.nil?
+          @default_leading
+        else
+          @default_leading = number
+        end
+      end
+
+      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 :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::DATADIR}/fonts/gkai00mp.ttf"
+      # font_families["Kai"] = {
+      #   :normal => { :file => file, :font => "Kai" }
+      # }
+      # file = "#{Prawn::DATADIR}/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.key?(mode)
+          raise ArgumentError, "mode must be between one of #{MODES.keys.join(', ')} (#{mode})"
+        end
+        original_mode = @text_rendering_mode || :fill
+        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.
+      # For veritical text, a positive value will decrease the space.
+      #
+      def character_spacing(amount=nil)
+        return @character_spacing || 0 if amount.nil?
+        original_character_spacing = character_spacing
+        if original_character_spacing == amount
+          yield
+        else
+          @character_spacing = amount
+          add_content "\n%.3f Tc" % amount
+          yield
+          add_content "\n%.3f Tc" % original_character_spacing
+          @character_spacing = original_character_spacing
+        end
+      end
+
+      # Increases or decreases the space between words.
+      # For horizontal text, a positive value will increase the space.
+      # For veritical text, a positive value will decrease the space.
+      #
+      def word_spacing(amount=nil)
+        return @word_spacing || 0 if amount.nil?
+        original_word_spacing = word_spacing
+        if original_word_spacing == amount
+          yield
+        else
+          @word_spacing = amount
+          add_content "\n%.3f Tw" % amount
+          yield
+          add_content "\n%.3f Tw" % original_word_spacing
+          @word_spacing = original_word_spacing
+        end
+      end
+
+      private
+
+      def add_text_content(text, x, y, options)
+        chunks = font.encode_text(text,options)
+
+        add_content "\nBT"
+
+        if options[:rotate]
+          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
+          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::Core::PdfObject(string, true) << " " << operation
+        end
+
+        add_content "ET\n"
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,294 @@
+# 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 Core
+    module Text
+      module Formatted #:nodoc:
+
+        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|
+              if ruby_18 { true }
+                fragment.text
+              else
+                fragment.text.dup.force_encoding("utf-8")
+              end
+            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 = [@max_line_height, fragment.line_height].compact.max
+            @max_descender = [@max_descender, fragment.descender].compact.max
+            @max_ascender = [@max_ascender, fragment.ascender].compact.max
+          end
+          
+        end
+
+      end
+    end
+  end
+end