prawn 1.0.0.rc2 → 1.0.0

data/lib/prawn/core/text.rb

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

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