prawn 0.15.0 → 1.0.0.rc1

data/lib/prawn/core/page.rb

@@ -0,0 +1,215 @@
+# encoding: utf-8
+
+# prawn/core/page.rb : Implements low-level representation of a PDF page
+#
+# Copyright February 2010, Gregory Brown.  All Rights Reserved.
+#
+# 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:
+
+      include Prawn::Core::Page::GraphicsState
+
+      attr_accessor :document, :content, :dictionary, :margins, :stack
+
+      def initialize(document, options={})
+        @document = document
+        @margins  = options[:margins] || { :left    => 36,
+                                           :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
+
+      def layout
+        return @layout if @layout
+
+        mb = dictionary.data[:MediaBox]
+        if mb[3] > mb[2]
+          :portrait
+        else
+          :landscape
+        end
+      end
+
+      def size
+        @size || dimensions[2,2]
+      end
+
+      def in_stamp_stream?
+        !!@stamp_stream
+      end
+
+      def stamp_stream(dictionary)
+        @stamp_stream     = ""
+        @stamp_dictionary = dictionary
+        graphic_stack_size = stack.stack.size
+
+        document.save_graphics_state
+        document.send(:freeze_stamp_graphics)
+        yield if block_given?
+
+        until graphic_stack_size == stack.stack.size
+          document.restore_graphics_state
+        end
+
+        @stamp_dictionary.data[:Length] = @stamp_stream.length + 1
+        @stamp_dictionary << @stamp_stream
+
+        @stamp_stream      = nil
+        @stamp_dictionary  = nil
+      end
+
+      def content
+        @stamp_stream || document.state.store[@content]
+      end
+
+      # As per the PDF spec, each page can have multiple content streams. This will
+      # add a fresh, empty content stream this the page, mainly for use in loading
+      # template files.
+      #
+      def new_content_stream
+        return if in_stamp_stream?
+
+        unless dictionary.data[:Contents].is_a?(Array)
+          dictionary.data[:Contents] = [content]
+        end
+        @content    = document.ref(:Length => 0)
+        dictionary.data[:Contents] << document.state.store[@content]
+        document.open_graphics_state
+      end
+
+      def dictionary
+        @stamp_dictionary || document.state.store[@dictionary]
+      end
+
+      def resources
+        if dictionary.data[:Resources]
+          document.deref(dictionary.data[:Resources])
+        else
+          dictionary.data[:Resources] = {}
+        end
+      end
+
+      def fonts
+        if resources[:Font]
+          document.deref(resources[:Font])
+        else
+          resources[:Font] = {}
+        end
+      end
+
+      def xobjects
+        if resources[:XObject]
+          document.deref(resources[:XObject])
+        else
+          resources[:XObject] = {}
+        end
+      end
+
+      def ext_gstates
+        if resources[:ExtGState]
+          document.deref(resources[:ExtGState])
+        else
+          resources[:ExtGState] = {}
+        end
+      end
+
+      def finalize
+        if dictionary.data[:Contents].is_a?(Array)
+          dictionary.data[:Contents].each do |stream|
+            stream.compress_stream if document.compression_enabled?
+            stream.data[:Length] = stream.stream.size
+          end
+        else
+          content.compress_stream if document.compression_enabled?
+          content.data[:Length] = content.stream.size
+        end
+      end
+
+      def imported_page?
+        @imported_page
+      end
+
+      def dimensions
+        return inherited_dictionary_value(:MediaBox) if imported_page?
+
+        coords = Prawn::Document::PageGeometry::SIZES[size] || size
+        [0,0] + case(layout)
+        when :portrait
+          coords
+        when :landscape
+          coords.reverse
+        else
+          raise Prawn::Errors::InvalidPageLayout,
+            "Layout must be either :portrait or :landscape"
+        end
+      end
+
+      private
+
+      def init_from_object(options)
+        @dictionary = options[:object_id].to_i
+        dictionary.data[:Parent] = document.state.store.pages
+
+        unless dictionary.data[:Contents].is_a?(Array) # content only on leafs
+          @content    = dictionary.data[:Contents].identifier
+        end
+
+        @stamp_stream      = nil
+        @stamp_dictionary  = nil
+        @imported_page     = true
+      end
+
+      def init_new_page(options)
+        @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,
+                                   :Contents    => content)
+
+        resources[:ProcSet] = [:PDF, :Text, :ImageB, :ImageC, :ImageI]
+
+        @stamp_stream      = nil
+        @stamp_dictionary  = nil
+      end
+
+      # some entries in the Page dict can be inherited from parent Pages dicts.
+      #
+      # Starting with the current page dict, this method will walk up the
+      # inheritance chain return the first value that is found for key
+      #
+      #     inherited_dictionary_value(:MediaBox)
+      #     => [ 0, 0, 595, 842 ]
+      #
+      def inherited_dictionary_value(key, local_dict = nil)
+        local_dict ||= dictionary.data
+
+        if local_dict.has_key?(key)
+          local_dict[key]
+        elsif local_dict.has_key?(:Parent)
+          inherited_dictionary_value(key, local_dict[:Parent].data)
+        else
+          nil
+        end
+      end
+
+    end
+
+  end
+end
+

data/lib/prawn/core/pdf_object.rb

@@ -0,0 +1,108 @@
+# encoding: utf-8
+#
+# pdf_object.rb : Handles Ruby to PDF object serialization
+#
+# Copyright April 2008, Gregory Brown.  All Rights Reserved.
+#
+# This is free software. Please see the LICENSE and COPYING files for details.
+
+# Top level Module
+#
+module Prawn 
+  module Core #:nodoc:
+                                             
+    module_function
+
+    if "".respond_to?(:encode)
+      # Ruby 1.9+
+      def utf8_to_utf16(str)
+        "\xFE\xFF".force_encoding("UTF-16BE") + str.encode("UTF-16BE")
+      end
+    else
+      # Ruby 1.8
+      def utf8_to_utf16(str)
+        utf16 = "\xFE\xFF"
+
+        str.unpack("U*").each do |cp|
+          if cp < 0x10000 # Basic Multilingual Plane
+            utf16 << [cp].pack("n")
+          else
+            # pull out high/low 10 bits
+            hi, lo = (cp - 0x10000).divmod(2**10)
+            # encode a surrogate pair
+            utf16 << [0xD800 + hi, 0xDC00 + lo].pack("n*")
+          end
+        end
+
+        utf16
+      end
+    end
+      
+    # Serializes Ruby objects to their PDF equivalents.  Most primitive objects
+    # will work as expected, but please note that Name objects are represented 
+    # by Ruby Symbol objects and Dictionary objects are represented by Ruby hashes
+    # (keyed by symbols)   
+    #
+    #  Examples:
+    #
+    #     PdfObject(true)      #=> "true"
+    #     PdfObject(false)     #=> "false" 
+    #     PdfObject(1.2124)    #=> "1.2124"
+    #     PdfObject("foo bar") #=> "(foo bar)"  
+    #     PdfObject(:Symbol)   #=> "/Symbol"
+    #     PdfObject(["foo",:bar, [1,2]]) #=> "[foo /bar [1 2]]"
+    # 
+    def PdfObject(obj, in_content_stream = false)
+      case(obj)        
+      when NilClass   then "null" 
+      when TrueClass  then "true"
+      when FalseClass then "false"
+      when Numeric    then String(obj)
+      when Array
+        "[" << obj.map { |e| PdfObject(e, in_content_stream) }.join(' ') << "]"
+      when Prawn::Core::LiteralString
+        obj = obj.gsub(/[\\\n\r\t\b\f\(\)]/n) { |m| "\\#{m}" }
+        "(#{obj})"
+      when Time
+        obj = obj.strftime("D:%Y%m%d%H%M%S%z").chop.chop + "'00'"
+        obj = obj.gsub(/[\\\n\r\t\b\f\(\)]/n) { |m| "\\#{m}" }
+        "(#{obj})"
+      when Prawn::Core::ByteString
+        "<" << obj.unpack("H*").first << ">"
+      when String
+        obj = utf8_to_utf16(obj) unless in_content_stream
+        "<" << obj.unpack("H*").first << ">"
+       when Symbol                                                         
+         "/" + obj.to_s.unpack("C*").map { |n|
+          if n < 33 || n > 126 || [35,40,41,47,60,62].include?(n)
+            "#" + n.to_s(16).upcase
+          else
+            [n].pack("C*")
+          end
+         }.join
+      when Hash           
+        output = "<< "
+        obj.each do |k,v|  
+          unless String === k || Symbol === k
+            raise Prawn::Errors::FailedObjectConversion, 
+              "A PDF Dictionary must be keyed by names"
+          end                          
+          output << PdfObject(k.to_sym, in_content_stream) << " " << 
+                    PdfObject(v, in_content_stream) << "\n"
+        end  
+        output << ">>"  
+      when Prawn::Core::Reference
+        obj.to_s      
+      when Prawn::Core::NameTree::Node
+        PdfObject(obj.to_hash)
+      when Prawn::Core::NameTree::Value
+        PdfObject(obj.name) + " " + PdfObject(obj.value)
+      when Prawn::OutlineRoot, Prawn::OutlineItem
+        PdfObject(obj.to_hash)
+      else
+        raise Prawn::Errors::FailedObjectConversion, 
+          "This object cannot be serialized to PDF (#{obj.inspect})"
+      end     
+    end   
+  end
+end

data/lib/prawn/core/reference.rb

@@ -0,0 +1,115 @@
+# encoding: utf-8
+
+# reference.rb : Implementation of PDF indirect objects
+#
+# Copyright April 2008, Gregory Brown.  All Rights Reserved.
+#
+# This is free software. Please see the LICENSE and COPYING files for details.
+
+require 'zlib'
+
+module Prawn  
+  module Core
+  
+    class Reference #:nodoc:
+
+      attr_accessor :gen, :data, :offset, :stream, :live, :identifier
+      
+      def initialize(id, data)
+        @identifier = id 
+        @gen        = 0       
+        @data       = data     
+        @compressed = false
+        @stream     = nil
+      end            
+      
+      def object 
+        output = "#{@identifier} #{gen} obj\n" <<
+                 Prawn::Core::PdfObject(data) << "\n"
+        if @stream
+          output << "stream\n" << @stream << "\nendstream\n" 
+        end
+        output << "endobj\n"
+      end  
+      
+      def <<(data)
+        raise 'Cannot add data to a stream that is compressed' if @compressed
+        (@stream ||= "") << data  
+      end  
+      
+      def to_s            
+        "#{@identifier} #{gen} R"
+      end
+
+      def compress_stream
+        @stream = Zlib::Deflate.deflate(@stream)
+        @data[:Filter] = :FlateDecode
+        @data[:Length] ||= @stream.length
+        @compressed = true
+      end
+
+      def compressed?
+        @compressed
+      end
+
+      # Creates a deep copy of this ref. If +share+ is provided, shares the
+      # given dictionary entries between the old ref and the new.
+      #
+      def deep_copy(share=[])
+        r = dup
+
+        case r.data
+        when Hash
+          # Copy each entry not in +share+.
+          (r.data.keys - share).each do |k|
+            r.data[k] = Marshal.load(Marshal.dump(r.data[k]))
+          end
+        when Prawn::Core::NameTree::Node
+          r.data = r.data.deep_copy
+        else
+          r.data = Marshal.load(Marshal.dump(r.data))
+        end
+
+        r.stream = Marshal.load(Marshal.dump(r.stream))
+        r
+      end
+      
+      # Replaces the data and stream with that of other_ref. Preserves compressed
+      # status.
+      def replace(other_ref)
+        @data       = other_ref.data
+        @stream     = other_ref.stream
+        @compressed = other_ref.compressed?
+      end
+
+      # Marks this and all referenced objects live, recursively.
+      def mark_live
+        return if @live
+        @live = true
+        referenced_objects.each { |o| o.mark_live }
+      end
+
+      private
+
+      # All objects referenced by this one. Used for GC.
+      def referenced_objects(obj=@data)
+        case obj
+        when self.class
+          []
+        when Hash
+          obj.values.map{|v| [v] + referenced_objects(v) }
+        when Array
+          obj.map{|v| [v] + referenced_objects(v) }
+        else []
+        end.flatten.grep(self.class)
+      end
+
+    end         
+
+    module_function
+    
+    def Reference(*args, &block) #:nodoc:
+      Reference.new(*args, &block)
+    end     
+  end
+end

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::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.
+      # 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