292 lines
8.6 KiB
Ruby
292 lines
8.6 KiB
Ruby
# frozen_string_literal: true
|
|
|
|
module TTFunk
|
|
class Table
|
|
class Cff < TTFunk::Table
|
|
# CFF Charset
|
|
class Charset < TTFunk::SubTable
|
|
include Enumerable
|
|
|
|
# First glyph string. This is an implicit glyph present in all charsets.
|
|
FIRST_GLYPH_STRING = '.notdef'
|
|
|
|
# Format 0.
|
|
ARRAY_FORMAT = 0
|
|
|
|
# Format 1.
|
|
RANGE_FORMAT_8 = 1
|
|
|
|
# Format 2.
|
|
RANGE_FORMAT_16 = 2
|
|
|
|
# Predefined ISOAdobe charset ID.
|
|
ISO_ADOBE_CHARSET_ID = 0
|
|
|
|
# Predefined Expert charset ID.
|
|
EXPERT_CHARSET_ID = 1
|
|
|
|
# Predefined Expert Subset charset ID.
|
|
EXPERT_SUBSET_CHARSET_ID = 2
|
|
|
|
# Default charset ID.
|
|
DEFAULT_CHARSET_ID = ISO_ADOBE_CHARSET_ID
|
|
|
|
class << self
|
|
# Standard strings defined in the spec that do not need to be defined
|
|
# in the CFF.
|
|
#
|
|
# @return [TTFunk::OneBasedArray<String>]
|
|
def standard_strings
|
|
Charsets::STANDARD_STRINGS
|
|
end
|
|
|
|
# Strings for charset ID.
|
|
#
|
|
# @param charset_id [Integer]
|
|
# @return [TTFunk::OneBasedArray<String>]
|
|
def strings_for_charset_id(charset_id)
|
|
case charset_id
|
|
when ISO_ADOBE_CHARSET_ID
|
|
Charsets::ISO_ADOBE
|
|
when EXPERT_CHARSET_ID
|
|
Charsets::EXPERT
|
|
when EXPERT_SUBSET_CHARSET_ID
|
|
Charsets::EXPERT_SUBSET
|
|
end
|
|
end
|
|
end
|
|
|
|
# Encoded entries.
|
|
# @return [TTFunk::OneBasedArray<Integer>, Array<Range<Integer>>]
|
|
attr_reader :entries
|
|
|
|
# Length of encoded charset subtable.
|
|
# @return [Integer]
|
|
attr_reader :length
|
|
|
|
# Top dict.
|
|
# @return [TTFunk::Table::Cff::TopDict]
|
|
attr_reader :top_dict
|
|
|
|
# Encodign format.
|
|
# @return [Integer]
|
|
attr_reader :format
|
|
|
|
# Number of encoded items.
|
|
# @return [Integer]
|
|
attr_reader :items_count
|
|
|
|
# Offset or charset ID.
|
|
# @return [Integer]
|
|
attr_reader :offset_or_id
|
|
|
|
# @overload initialize(top_dict, file, offset = nil, length = nil)
|
|
# @param top_dict [TTFunk::Table:Cff::TopDict]
|
|
# @param file [TTFunk::File]
|
|
# @param offset [Integer]
|
|
# @param length [Integer]
|
|
# @overload initialize(top_dict, file, charset_id)
|
|
# @param top_dict [TTFunk::Table:Cff::TopDict]
|
|
# @param file [TTFunk::File]
|
|
# @param charset_id [Integer] 0, 1, or 2
|
|
def initialize(top_dict, file, offset_or_id = nil, length = nil)
|
|
@top_dict = top_dict
|
|
@offset_or_id = offset_or_id || DEFAULT_CHARSET_ID
|
|
|
|
if offset
|
|
super(file, offset, length)
|
|
else
|
|
@items_count = self.class.strings_for_charset_id(offset_or_id).size
|
|
end
|
|
end
|
|
|
|
# Iterate over character names.
|
|
#
|
|
# @overload each()
|
|
# @yieldparam name [String]
|
|
# @return [void]
|
|
# @overload each()
|
|
# @return [Enumerator]
|
|
def each
|
|
return to_enum(__method__) unless block_given?
|
|
|
|
# +1 adjusts for the implicit .notdef glyph
|
|
(items_count + 1).times { |i| yield(self[i]) }
|
|
end
|
|
|
|
# Get character name for glyph index.
|
|
#
|
|
# @param glyph_id [Integer]
|
|
# @return [String, nil]
|
|
def [](glyph_id)
|
|
return FIRST_GLYPH_STRING if glyph_id.zero?
|
|
|
|
find_string(sid_for(glyph_id))
|
|
end
|
|
|
|
# Charset offset in the file.
|
|
#
|
|
# @return [Integer, nil]
|
|
def offset
|
|
# Numbers from 0..2 mean charset IDs instead of offsets. IDs are
|
|
# basically pre-defined sets of characters.
|
|
#
|
|
# In the case of an offset, add the CFF table's offset since the
|
|
# charset offset is relative to the start of the CFF table. Otherwise
|
|
# return nil (no offset).
|
|
if offset_or_id > 2
|
|
offset_or_id + top_dict.cff_offset
|
|
end
|
|
end
|
|
|
|
# Encode charset.
|
|
#
|
|
# @param charmap [Hash{Integer => Hash}] keys are the charac codes,
|
|
# values are hashes:
|
|
# * `:old` (<tt>Integer</tt>) - glyph ID in the original font.
|
|
# * `:new` (<tt>Integer</tt>) - glyph ID in the subset font.
|
|
# @return [String]
|
|
def encode(charmap)
|
|
# no offset means no charset was specified (i.e. we're supposed to
|
|
# use a predefined charset) so there's nothing to encode
|
|
return '' unless offset
|
|
|
|
sids =
|
|
charmap
|
|
.values
|
|
.reject { |mapping| mapping[:new].zero? }
|
|
.sort_by { |mapping| mapping[:new] }
|
|
.map { |mapping| sid_for(mapping[:old]) }
|
|
|
|
ranges = TTFunk::BinUtils.rangify(sids)
|
|
range_max = ranges.map(&:last).max
|
|
|
|
range_bytes =
|
|
if range_max.positive?
|
|
(Math.log2(range_max) / 8).floor + 1
|
|
else
|
|
# for cases when there are no sequences at all
|
|
Float::INFINITY
|
|
end
|
|
|
|
# calculate whether storing the charset as a series of ranges is
|
|
# more efficient (i.e. takes up less space) vs storing it as an
|
|
# array of SID values
|
|
total_range_size = (2 * ranges.size) + (range_bytes * ranges.size)
|
|
total_array_size = sids.size * element_width(:array_format)
|
|
|
|
if total_array_size <= total_range_size
|
|
([format_int(:array_format)] + sids).pack('Cn*')
|
|
else
|
|
fmt = range_bytes == 1 ? :range_format8 : :range_format16
|
|
element_fmt = element_format(fmt)
|
|
result = [format_int(fmt)].pack('C')
|
|
ranges.each { |range| result << range.pack(element_fmt) }
|
|
result
|
|
end
|
|
end
|
|
|
|
private
|
|
|
|
def sid_for(glyph_id)
|
|
return 0 if glyph_id.zero?
|
|
|
|
# rather than validating the glyph as part of one of the predefined
|
|
# charsets, just pass it through
|
|
return glyph_id unless offset
|
|
|
|
case format_sym
|
|
when :array_format
|
|
entries[glyph_id]
|
|
|
|
when :range_format8, :range_format16
|
|
entries.reduce(glyph_id) do |remaining, range|
|
|
if range.size >= remaining
|
|
break (range.first + remaining) - 1
|
|
end
|
|
|
|
remaining - range.size
|
|
end
|
|
end
|
|
end
|
|
|
|
def find_string(sid)
|
|
if offset
|
|
return self.class.standard_strings[sid] if sid <= 390
|
|
|
|
idx = sid - 390
|
|
|
|
if idx < file.cff.string_index.items_count
|
|
file.cff.string_index[idx]
|
|
end
|
|
else
|
|
self.class.strings_for_charset_id(offset_or_id)[sid]
|
|
end
|
|
end
|
|
|
|
def parse!
|
|
return unless offset
|
|
|
|
@format = read(1, 'C').first
|
|
|
|
case format_sym
|
|
when :array_format
|
|
@items_count = top_dict.charstrings_index.items_count - 1
|
|
@length = @items_count * element_width
|
|
@entries = OneBasedArray.new(read(length, 'n*'))
|
|
|
|
when :range_format8, :range_format16
|
|
# The number of ranges is not explicitly specified in the font.
|
|
# Instead, software utilizing this data simply processes ranges
|
|
# until all glyphs in the font are covered.
|
|
@items_count = 0
|
|
@entries = []
|
|
@length = 0
|
|
|
|
until @items_count >= top_dict.charstrings_index.items_count - 1
|
|
@length += 1 + element_width
|
|
sid, num_left = read(element_width, element_format)
|
|
@entries << (sid..(sid + num_left))
|
|
@items_count += num_left + 1
|
|
end
|
|
end
|
|
end
|
|
|
|
def element_width(fmt = format_sym)
|
|
{
|
|
array_format: 2, # SID
|
|
range_format8: 3, # SID + Card8
|
|
range_format16: 4, # SID + Card16
|
|
}[fmt]
|
|
end
|
|
|
|
def element_format(fmt = format_sym)
|
|
{
|
|
array_format: 'n',
|
|
range_format8: 'nC',
|
|
range_format16: 'nn',
|
|
}[fmt]
|
|
end
|
|
|
|
def format_sym
|
|
case @format
|
|
when ARRAY_FORMAT then :array_format
|
|
when RANGE_FORMAT_8 then :range_format8
|
|
when RANGE_FORMAT_16 then :range_format16
|
|
else
|
|
raise Error, "unsupported charset format '#{fmt}'"
|
|
end
|
|
end
|
|
|
|
def format_int(sym = format_sym)
|
|
{
|
|
array_format: ARRAY_FORMAT,
|
|
range_format8: RANGE_FORMAT_8,
|
|
range_format16: RANGE_FORMAT_16,
|
|
}[sym]
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|