class Prawn::Fonts::AFM

AFM font. AFM stands for Adobe Font Metrics. It’s not a complete font, it doesn’t provide actual glyph outlines. It only contains glyph metrics to make text layout possible. AFM is used for PDF built-in fonts. Those fonts are supposed to be present on the target system making it possible to save a little bit of space by not embedding the fonts. A file that uses these fonts can not be read on a system that doesn’t have these fonts installed.

@note You shouldn’t use this class directly.

Constants

BUILT_INS: List of PDF built-in fonts.

Attributes

hide_m17n_warning [RW]

Prawn would warn you if you’re using non-ASCII glyphs with AFM fonts as not all implementations provide those glyphs. This attribute suppresses that warning.

@return [Boolean] (false)

attributes [R]

@private

Public Class Methods

font_data ()

Source

# File lib/prawn/fonts/afm.rb, line 66
def self.font_data
  @font_data ||= SynchronizedCache.new
end

Parsed AFM data cache.

@return [SynchronizedCache]

metrics_path ()

Source

# File lib/prawn/fonts/afm.rb, line 46
def self.metrics_path
  @metrics_path ||=
    if ENV['METRICS']
      ENV['METRICS'].split(':')
    else
      [
        '.', '/usr/lib/afm',
        '/usr/local/lib/afm',
        '/usr/openwin/lib/fonts/afm',
        "#{Prawn::DATADIR}/fonts",
      ]
    end
end

Paths to look for AFM files at.

@return [Array<String>]

new (document, name, options = {})

Source

# File lib/prawn/fonts/afm.rb, line 75
def initialize(document, name, options = {})
  name ||= options[:family]
  unless BUILT_INS.include?(name)
    raise Prawn::Errors::UnknownFont,
      "#{name} (#{options[:style] || 'normal'}) is not a known font."
  end

  super

  file_name = @name.dup
  file_name << '.afm' unless /\.afm$/.match?(file_name)
  file_name = find_font(file_name) unless file_name[0] == '/'

  font_data = self.class.font_data[file_name] ||= parse_afm(file_name)
  @glyph_widths = font_data[:glyph_widths]
  @glyph_table = font_data[:glyph_table]
  @bounding_boxes = font_data[:bounding_boxes]
  @kern_pairs = font_data[:kern_pairs]
  @kern_pair_table = font_data[:kern_pair_table]
  @attributes = font_data[:attributes]

  @ascender = Integer(@attributes.fetch('ascender', '0'), 10)
  @descender = Integer(@attributes.fetch('descender', '0'), 10)
  @line_gap = Float(bbox[3] - bbox[1]) - (@ascender - @descender)
end

@param document [Prawn::Document] @param name [String] @param options [Hash] @option options :family [String] @option options :style [Symbol]

Calls superclass method Prawn::Font::new

Public Instance Methods

bbox ()

Source

# File lib/prawn/fonts/afm.rb, line 104
def bbox
  @bbox ||= @attributes['fontbbox'].split(/\s+/).map { |e| Integer(e) }
end

The font bbox.

@return [Array(Number, Number, Number, Number)]

character_count (str)

Source

# File lib/prawn/fonts/afm.rb, line 165
def character_count(str)
  str.length
end

Returns the number of characters in ‘str` (a WinAnsi-encoded string).

@param str [String] @return [Integer]

compute_width_of (string, options = {})

Source

# File lib/prawn/fonts/afm.rb, line 116
def compute_width_of(string, options = {})
  scale = (options[:size] || size) / 1000.0

  if options[:kerning]
    strings, numbers = kern(string).partition { |e| e.is_a?(String) }
    total_kerning_offset = numbers.sum
    (unscaled_width_of(strings.join) - total_kerning_offset) * scale
  else
    unscaled_width_of(string) * scale
  end
end

Compute width of a string at the specified size, optionally with kerning applied.

@param string [String] must be encoded as WinAnsi @param options [Hash{Symbol => any}] @option options :size [Number] @option options :kerning [Boolean] (false) @return [Number]

encode_text (text, options = {})

Source

# File lib/prawn/fonts/afm.rb, line 185
def encode_text(text, options = {})
  [[0, options[:kerning] ? kern(text) : text]]
end

Perform any changes to the string that need to happen before it is rendered to the canvas. Returns an array of subset “chunks”, where each chunk is an array of two elements. The first element is the font subset number, and the second is either a string or an array (for kerned text).

For Adobe fonts, there is only ever a single subset, so the first element of the array is ‘0`, and the second is the string itself (or an array, if kerning is performed).

The ‘text` argument must be in WinAnsi encoding (cp1252).

@param text [String] @param options [Hash{Symbol => any}] @option options :kerning [Boolean] @return [Array<Array(0, (String, Array)>]

glyph_present? (char)

Source

# File lib/prawn/fonts/afm.rb, line 193
def glyph_present?(char)
  !normalize_encoding(char).nil?
rescue Prawn::Errors::IncompatibleStringEncoding
  false
end

Does this font has a glyph for the character?

@param char [String] @return [Boolean]

has_kerning_data? ()

Source

# File lib/prawn/fonts/afm.rb, line 131
def has_kerning_data? # rubocop: disable Naming/PredicateName
  @kern_pairs.any?
end

Does this font contain kerning data.

@return [Boolean]

normalize_encoding (text)

Source

# File lib/prawn/fonts/afm.rb, line 141
def normalize_encoding(text)
  text.encode('windows-1252')
rescue ::Encoding::InvalidByteSequenceError,
       ::Encoding::UndefinedConversionError

  raise Prawn::Errors::IncompatibleStringEncoding,
    "Your document includes text that's not compatible with the " \
      "Windows-1252 character set.\n" \
      'If you need full UTF-8 support, use external fonts instead of ' \
      "PDF's built-in fonts.\n"
end

Built-in fonts only work with WinAnsi encoding, so translate the string. Changes the encoding in-place, so the argument itself is replaced with a string in WinAnsi encoding.

@param text [String] @return [String]

to_utf8 (text)

Source

# File lib/prawn/fonts/afm.rb, line 157
def to_utf8(text)
  text.encode('UTF-8')
end

Encode text to UTF-8.

@param text [String] @return [String]

unicode? ()

Source

# File lib/prawn/fonts/afm.rb, line 39
def unicode?
  false
end

Does this font support Unicode?

@return [false]