prawn-core 0.5.0.1

data/lib/prawn/document/text/box.rb

@@ -0,0 +1,83 @@
+# encoding: utf-8
+
+# text/box.rb : Implements simple text boxes
+#
+# Copyright September 2008, Gregory Brown. All Rights Reserved.
+#
+# This is free software. Please see the LICENSE and COPYING files for details.
+
+module Prawn
+  class Document
+    
+    # Defines an invisible rectangle which you can flow text in. When the
+    # text overflows the box, you can either display :ellipses, :truncate
+    # the text, or allow it to overflow the bottom boundary with :expand.
+    #
+    #   text_box "Oh hai text box. " * 200, 
+    #     :width    => 300, :height => font.height * 5,
+    #     :overflow => :ellipses, 
+    #     :at       => [100,bounds.top]
+    #
+    def text_box(text,options)
+      Text::Box.new(text, options.merge(:for => self)).render
+    end
+    
+    module Text 
+      class Box #:nodoc:
+        def initialize(text,options={})
+          @document  = options[:for]
+          @text      = text
+          @at        = options[:at] || [0, @document.y - @document.bounds.absolute_bottom]
+          @width     = options[:width] || @document.bounds.width
+          @height    = options[:height]
+          @overflow  = options[:overflow] || :truncate
+        end
+
+        attr_reader :text, :width, :height, :overflow
+        
+        def render
+          x,y = @at
+          
+          if @overflow == :expand
+            @text = naive_wrap_text
+          else
+            original_y = @document.y
+            fit_text_to_box            
+          end
+          
+          @document.bounding_box([x,@document.bounds.top], 
+            :width => @width, :height => @document.bounds.height) do
+            @document.y = @document.bounds.absolute_bottom + y 
+            @document.text @text
+          end
+          
+          unless @overflow == :expand
+            @document.y = y + @document.bounds.absolute_bottom - @height  
+          end        
+        end
+        
+        private        
+        
+        def fit_text_to_box
+          text = naive_wrap_text
+            
+          max_lines = (@height / @document.font.height).floor
+
+          lines = text.lines.to_a
+          
+          if lines.length > max_lines
+            @text = lines[0...max_lines].join
+            case(@overflow)
+            when :ellipses
+              @text[-3..-1] = "..." if @text.size > 3
+            end
+          end 
+        end
+        
+        def naive_wrap_text
+          @document.naive_wrap(@text, @width, @document.font_size)
+        end
+      end
+    end
+  end
+end

data/lib/prawn/document/text/wrapping.rb

@@ -0,0 +1,59 @@
+# encoding: utf-8
+
+# wrapping.rb : Implementation of naive text wrap
+#
+# Copyright May 2008, Michael Daines. All Rights Reserved.
+#
+# This is free software. Please see the LICENSE and COPYING files for details.
+module Prawn
+  class Document
+    module Text
+      module Wrapping #:nodoc:                
+        ruby_18 { $KCODE="U" }
+        
+        # Gets height of text in PDF points at current font size.
+        # Text +:line_width+ must be specified in PDF points.
+        #
+        # If using an AFM, string *must* be encoded as WinAnsi
+        # (Use normalize_encoding to convert)
+        #
+        def height_of(string, line_width, size=font_size)
+          string = naive_wrap(string, line_width, size)
+          string.lines.to_a.length * font.height_at(size)
+        end
+
+        # TODO: Replace with TeX optimal algorithm
+        def naive_wrap(string, line_width, font_size, options = {})
+          scan_pattern = options[:mode] == :character ? /./ : /\S+|\s+/                                    
+          
+          output = ""                
+          string.lines.each do |line| 
+            accumulated_width = 0        
+            segments = line.scan(scan_pattern)
+                                          
+            segments.each do |segment|    
+              segment_width = width_of(segment, :size => font_size, :kerning => options[:kerning]) 
+        
+              if (accumulated_width + segment_width).round > line_width.round
+                output = "#{output.sub(/[ \t]*\n?(\n*)\z/, "\n\\1")}"
+                
+                if segment =~ /\s/           
+                  accumulated_width = 0
+                else
+                  output << segment
+                  accumulated_width = segment_width
+                end
+              else                           
+                output << segment
+                accumulated_width += segment_width
+              end
+            end    
+          end
+
+          output
+        end
+        
+      end  
+    end
+  end
+end

data/lib/prawn/encoding.rb

@@ -0,0 +1,121 @@
+# encoding: utf-8
+#
+# Copyright September 2008, Gregory Brown, James Healy  All Rights Reserved.
+#
+# This is free software. Please see the LICENSE and COPYING files for details.
+#
+module Prawn
+  module Encoding
+    # Map between unicode and WinAnsiEnoding
+    #
+    class WinAnsi #:nodoc:
+      CHARACTERS = %w[
+        .notdef       .notdef        .notdef        .notdef
+        .notdef       .notdef        .notdef        .notdef
+        .notdef       .notdef        .notdef        .notdef
+        .notdef       .notdef        .notdef        .notdef
+        .notdef       .notdef        .notdef        .notdef
+        .notdef       .notdef        .notdef        .notdef
+        .notdef       .notdef        .notdef        .notdef
+        .notdef       .notdef        .notdef        .notdef
+        
+        space         exclam         quotedbl       numbersign
+        dollar        percent        ampersand      quotesingle
+        parenleft     parenright     asterisk       plus
+        comma         hyphen         period         slash
+        zero          one            two            three
+        four          five           six            seven
+        eight         nine           colon          semicolon
+        less          equal          greater        question
+
+        at            A              B              C
+        D             E              F              G
+        H             I              J              K
+        L             M              N              O
+        P             Q              R              S
+        T             U              V              W
+        X             Y              Z              bracketleft
+        backslash     bracketright   asciicircum    underscore
+
+        grave         a              b              c
+        d             e              f              g
+        h             i              j              k
+        l             m              n              o
+        p             q              r              s
+        t             u              v              w
+        x             y              z              braceleft
+        bar           braceright     asciitilde     .notdef
+
+        Euro          .notdef        quotesinglbase florin
+        quotedblbase  ellipsis       dagger         daggerdbl
+        circumflex    perthousand    Scaron         guilsinglleft
+        OE            .notdef        Zcaron         .notdef
+        .notdef       quoteleft      quoteright     quotedblleft
+        quotedblright bullet         endash         emdash
+        tilde         trademark      scaron         guilsinglright
+        oe            .notdef        zcaron         ydieresis
+       
+        space         exclamdown     cent           sterling
+        currency      yen            brokenbar      section
+        dieresis      copyright      ordfeminine    guillemotleft
+        logicalnot    hyphen         registered     macron
+        degree        plusminus      twosuperior    threesuperior
+        acute         mu             paragraph      periodcentered
+        cedilla       onesuperior    ordmasculine   guillemotright
+        onequarter    onehalf        threequarters  questiondown
+
+        Agrave        Aacute         Acircumflex    Atilde
+        Adieresis     Aring          AE             Ccedilla
+        Egrave        Eacute         Ecircumflex    Edieresis
+        Igrave        Iacute         Icircumflex    Idieresis
+        Eth           Ntilde         Ograve         Oacute
+        Ocircumflex   Otilde         Odieresis      multiply
+        Oslash        Ugrave         Uacute         Ucircumflex
+        Udieresis     Yacute         Thorn          germandbls
+
+        agrave        aacute         acircumflex    atilde
+        adieresis     aring          ae             ccedilla
+        egrave        eacute         ecircumflex    edieresis
+        igrave        iacute         icircumflex    idieresis
+        eth           ntilde         ograve         oacute
+        ocircumflex   otilde         odieresis      divide
+        oslash        ugrave         uacute         ucircumflex
+        udieresis     yacute         thorn          ydieresis
+      ]    
+      
+      def initialize
+        @mapping_file = "#{Prawn::BASEDIR}/data/encodings/win_ansi.txt"
+        load_mapping if self.class.mapping.empty?
+      end
+
+      # Converts a Unicode codepoint into a valid WinAnsi single byte character.
+      #
+      # If there is no WinAnsi equivlant for a character, a _ will be substituted.
+      #
+      def [](codepoint)
+        # unicode codepoints < 255 map directly to the single byte value in WinAnsi
+        return codepoint if codepoint <= 255
+
+        # There are a handful of codepoints > 255 that have equivilants in WinAnsi.
+        # Replace anything else with an underscore
+        self.class.mapping[codepoint] || 95
+      end
+      
+      def self.mapping
+        @mapping ||= {}
+      end
+
+      private
+
+      def load_mapping
+        RUBY_VERSION >= "1.9" ? mode = "r:BINARY" : mode = "r"
+        File.open(@mapping_file, mode) do |f|
+          f.each do |l|
+            m, single_byte, unicode = *l.match(/([0-9A-Za-z]+);([0-9A-F]{4})/)
+            self.class.mapping["0x#{unicode}".hex] = "0x#{single_byte}".hex if single_byte
+          end
+        end
+      end
+    end
+  end
+end

data/lib/prawn/errors.rb

@@ -0,0 +1,49 @@
+# encoding: utf-8
+
+# errors.rb : Implements custom error classes for Prawn
+#
+# Copyright April 2008, Gregory Brown.  All Rights Reserved.
+#
+# This is free software. Please see the LICENSE and COPYING files for details.
+
+module Prawn
+  module Errors
+     
+     # This error is raised when Prawn::PdfObject() encounters a Ruby object it
+     # cannot convert to PDF
+     #
+     FailedObjectConversion = Class.new(StandardError)
+     
+     # This error is raised when Document#page_layout is set to anything
+     # other than :portrait or :landscape            
+     #
+     InvalidPageLayout = Class.new(StandardError)       
+     
+     # This error is raised when a method requiring a current page is called 
+     # without being on a page.
+     #
+     NotOnPage = Class.new(StandardError)
+     
+     # This error is raised when Prawn cannot find a specified font   
+     #
+     UnknownFont = Class.new(StandardError)   
+
+     # This error is raised when Prawn is being used on a M17N aware VM,
+     # and the user attempts to add text that isn't compatible with UTF-8
+     # to their document
+     #
+     IncompatibleStringEncoding = Class.new(StandardError)
+     
+     # This error is raised when Prawn encounters an unknown key in functions
+     # that accept an options hash.  This usually means there is a typo in your
+     # code or that the option you are trying to use has a different name than
+     # what you have specified. 
+     #
+     UnknownOption = Class.new(StandardError)
+
+     # this error is raised when a user attempts to embed an image of an unsupported
+     # type. This can either a completely unsupported format, or a dialect of a
+     # supported format (ie. some types of PNG)
+     UnsupportedImageType = Class.new(StandardError)
+  end
+end   

data/lib/prawn/font.rb

@@ -0,0 +1,292 @@
+# encoding: utf-8
+#
+# font.rb : The Prawn font class
+#
+# Copyright May 2008, Gregory Brown / James Healy. All Rights Reserved.
+#
+# This is free software. Please see the LICENSE and COPYING files for details.
+require "prawn/font/afm"
+require "prawn/font/ttf"
+require "prawn/font/dfont"
+
+module Prawn
+
+  class Document
+    # Without arguments, this returns the currently selected font. Otherwise,
+    # it sets the current font.
+    #
+    # The single parameter must be a string. It can be one of the 14 built-in
+    # fonts supported by PDF, or the location of a TTF file. The Font::AFM::BUILT_INS
+    # array specifies the valid built in font values.
+    #
+    #   pdf.font "Times-Roman"
+    #   pdf.font "Chalkboard.ttf"
+    #
+    # If a ttf font is specified, the glyphs necessary to render your document
+    # will be embedded in the rendered PDF. This should be your preferred option
+    # in most cases. It will increase the size of the resulting file, but also 
+    # make it more portable.
+    #
+    def font(name=nil, options={})
+      return @font || font("Helvetica") if name.nil?
+
+      raise Errors::NotOnPage unless @current_page
+      new_font = find_font(name, options)
+
+      if block_given?
+        save_font do
+          set_font(new_font, options[:size])
+          yield
+        end
+      else
+        set_font(new_font, options[:size])
+      end
+
+      @font
+    end
+
+    # When called with no argument, returns the current font size.
+    # When called with a single argument but no block, sets the current font
+    # size.  When a block is used, the font size is applied transactionally and
+    # is rolled back when the block exits.  You may still change the font size
+    # within a transactional block for individual text segments, or nested calls
+    # to font_size.
+    #
+    #   Prawn::Document.generate("font_size.pdf") do
+    #     font_size 16
+    #     text "At size 16"
+    #
+    #     font_size(10) do
+    #       text "At size 10"
+    #       text "At size 6", :size => 6
+    #       text "At size 10"
+    #     end
+    #
+    #     text "At size 16"
+    #   end
+    #
+    # When called without an argument, this method returns the current font
+    # size.
+    #
+    def font_size(points=nil)
+      return @font_size unless points
+      size_before_yield = @font_size
+      @font_size = points
+      block_given? ? yield : return
+      @font_size = size_before_yield
+    end
+
+    # Sets the font directly, given an actual Font object
+    # and size.
+    def set_font(font, size=nil) # :nodoc:
+      @font = font
+      @font_size = size if size
+    end
+
+    # Saves the current font, and then yields. When the block
+    # finishes, the original font is restored.
+    def save_font
+      @font ||= find_font("Helvetica")
+      original_font = @font
+      original_size = @font_size
+
+      yield
+    ensure
+      set_font(original_font, original_size) if original_font
+    end
+
+    # Looks up the given font using the given criteria. Once a font has been
+    # found by that matches the criteria, it will be cached to subsequent lookups
+    # for that font will return the same object.
+    #--
+    # Challenges involved: the name alone is not sufficient to uniquely identify
+    # a font (think dfont suitcases that can hold multiple different fonts in a
+    # single file). Thus, the :name key is included in the cache key.
+    #
+    # It is further complicated, however, since fonts in some formats (like the
+    # dfont suitcases) can be identified either by numeric index, OR by their
+    # name within the suitcase, and both should hash to the same font object
+    # (to avoid the font being embedded multiple times). This is not yet implemented,
+    # which means if someone selects a font both by name, and by index, the
+    # font will be embedded twice. Since we do font subsetting, this double
+    # embedding won't be catastrophic, just annoying.
+    # ++
+    #
+    def find_font(name, options={}) #:nodoc:
+      if font_families.key?(name)
+        family, name = name, font_families[name][options[:style] || :normal]
+
+        if name.is_a?(Hash)
+          options = options.merge(name)
+          name = options[:file]
+        end
+      end
+
+      key = "#{name}:#{options[:font] || 0}"
+      font_registry[key] ||= Font.load(self, name, options.merge(:family => family))
+    end
+
+    # Hash of Font objects keyed by names
+    #
+    def font_registry #:nodoc:
+      @font_registry ||= {}
+    end
+
+    # Hash that maps font family names to their styled individual font names
+    #
+    # To add support for another font family, append to this hash, e.g:
+    #
+    #   pdf.font_families.update(
+    #    "MyTrueTypeFamily" => { :bold        => "foo-bold.ttf",
+    #                            :italic      => "foo-italic.ttf",
+    #                            :bold_italic => "foo-bold-italic.ttf",
+    #                            :normal      => "foo.ttf" })
+    #
+    # This will then allow you to use the fonts like so:
+    #
+    #   pdf.font("MyTrueTypeFamily", :style => :bold)
+    #   pdf.text "Some bold text"
+    #   pdf.font("MyTrueTypeFamily")
+    #   pdf.text "Some normal text"
+    #
+    # This assumes that you have appropriate TTF fonts for each style you
+    # wish to support.
+    #
+    def font_families
+      @font_families ||= Hash.new { |h,k| h[k] = {} }.merge!(
+        { "Courier"     => { :bold        => "Courier-Bold",
+                             :italic      => "Courier-Oblique",
+                             :bold_italic => "Courier-BoldOblique",
+                             :normal      => "Courier" },
+
+          "Times-Roman" => { :bold         => "Times-Bold",
+                             :italic       => "Times-Italic",
+                             :bold_italic  => "Times-BoldItalic",
+                             :normal       => "Times-Roman" },
+
+          "Helvetica"   => { :bold         => "Helvetica-Bold",
+                             :italic       => "Helvetica-Oblique",
+                             :bold_italic  => "Helvetica-BoldOblique",
+                             :normal       => "Helvetica" }
+        })
+    end
+
+    # Returns the width of the given string using the given font. If :size is not
+    # specified as one of the options, the string is measured using the current
+    # font size. You can also pass :kerning as an option to indicate whether
+    # kerning should be used when measuring the width (defaults to +false+).
+    #
+    # Note that the string _must_ be encoded properly for the font being used.
+    # For AFM fonts, this is WinAnsi. For TTF, make sure the font is encoded as
+    # UTF-8. You can use the Font#normalize_encoding method to make sure strings
+    # are in an encoding appropriate for the current font.
+    #--
+    # For the record, this method used to be a method of Font (and still delegates
+    # to width computations on Font). However, having the primary interface for
+    # calculating string widths exist on Font made it tricky to write extensions
+    # for Prawn in which widths are computed differently (e.g., taking formatting
+    # tags into account, or the like).
+    #
+    # By putting width_of here, on Document itself, extensions may easily override
+    # it and redefine the width calculation behavior.
+    #++
+    def width_of(string, options={})
+      font.compute_width_of(string, options)
+    end
+  end
+
+  # Provides font information and helper functions.
+  #
+  class Font
+
+    # The current font name
+    attr_reader :name
+
+    # The current font family
+    attr_reader :family
+
+    # The options hash used to initialize the font
+    attr_reader :options
+
+    def self.load(document,name,options={})
+      case name
+      when /\.ttf$/   then TTF.new(document, name, options)
+      when /\.dfont$/ then DFont.new(document, name, options)
+      when /\.afm$/   then AFM.new(document, name, options)
+      else                 AFM.new(document, name, options)
+      end
+    end
+
+    def initialize(document,name,options={}) #:nodoc:
+      @document   = document
+      @name       = name
+      @options    = options
+
+      @family     = options[:family]
+
+      @document.proc_set :PDF, :Text
+      @identifier = :"F#{@document.font_registry.size + 1}"
+
+      @references = {}
+    end
+
+    def ascender
+      @ascender / 1000.0 * size
+    end
+
+    def descender
+      @descender / 1000.0 * size
+    end
+
+    def line_gap
+      @line_gap / 1000.0 * size
+    end
+
+    def identifier_for(subset)
+      "#{@identifier}.#{subset}"
+    end
+
+    def inspect
+      "#{self.class.name}< #{name}: #{size} >"
+    end
+
+    # Normalizes the encoding of the string to an encoding supported by the font.
+    # The string is expected to be UTF-8 going in, and will be reencoded in-place
+    # (the argument will be modified directly). The return value is not defined.
+    def normalize_encoding(string)
+      raise NotImplementedError, "subclasses of Prawn::Font must implement #normalize_encoding"
+    end
+
+    def normalize_encoding!(str)
+      str.replace(normalize_encoding(str))
+    end
+
+    def height_at(size)
+      @normalized_height ||= (@ascender - @descender + @line_gap) / 1000.0
+      @normalized_height * size
+    end
+
+    # Gets height of current font in PDF points at current font size
+    #
+    def height
+      height_at(size)
+    end
+
+    # Registers the given subset of the current font with the current PDF
+    # page. This is safe to call multiple times for a given font and subset,
+    # as it will only add the font the first time it is called.
+    #
+    def add_to_current_page(subset)
+      @references[subset] ||= register(subset)
+      @document.page_fonts.merge!(identifier_for(subset) => @references[subset])
+    end
+
+    private
+
+    def size
+      @document.font_size
+    end
+
+  end
+
+end