"""Make one string from sequence of strings, with whitespace

currpos = 0

lasti = 0

result = []

for i, s in enumerate(strings):

length = len(s)

if currpos + length < linelen:

currpos += length + 1

else:

result.append(b' '.join(strings[lasti:i]))

lasti = i

currpos = length

result.append(b' '.join(strings[lasti:]))

m = match.group(0)

if m in br'\()':

return b'\\' + m

elif m == b'\n':

return br'\n'

elif m == b'\r':

return br'\r'

"""Map Python objects to PDF syntax."""

# Some objects defined later have their own pdfRepr method.

if hasattr(obj, 'pdfRepr'):

return obj.pdfRepr()

# Floats. PDF does not have exponential notation (1.0e-10) so we

# need to use %f with some precision. Perhaps the precision

# should adapt to the magnitude of the number?

elif isinstance(obj, (float, np.floating)):

if not np.isfinite(obj):

raise ValueError("Can only output finite numbers in PDF")

r = ("%.10f" % obj).encode('ascii')

return r.rstrip(b'0').rstrip(b'.')

# Booleans. Needs to be tested before integers since

# isinstance(True, int) is true.

elif isinstance(obj, bool):

return [b'false', b'true'][obj]

# Integers are written as such.

elif isinstance(obj, (six.integer_types, np.integer)):

return ("%d" % obj).encode('ascii')

# Unicode strings are encoded in UTF-16BE with byte-order mark.

elif isinstance(obj, six.text_type):

try:

# But maybe it's really ASCII?

s = obj.encode('ASCII')

return pdfRepr(s)

except UnicodeEncodeError:

s = codecs.BOM_UTF16_BE + obj.encode('UTF-16BE')

return pdfRepr(s)

# Strings are written in parentheses, with backslashes and parens

# escaped. Actually balanced parens are allowed, but it is

# simpler to escape them all. TODO: cut long strings into lines;

# I believe there is some maximum line length in PDF.

elif isinstance(obj, bytes):

return b'(' + _string_escape_regex.sub(_string_escape, obj) + b')'

# Dictionaries. The keys must be PDF names, so if we find strings

# there, we make Name objects from them. The values may be

# anything, so the caller must ensure that PDF names are

# represented as Name objects.

elif isinstance(obj, dict):

r = [b"<<"]

r.extend([Name(key).pdfRepr() + b" " + pdfRepr(obj[key])

for key in sorted(obj)])

r.append(b">>")

return fill(r)

# Lists.

elif isinstance(obj, (list, tuple)):

r = [b"["]

r.extend([pdfRepr(val) for val in obj])

r.append(b"]")

return fill(r)

# The null keyword.

elif obj is None:

return b'null'

# A date.

elif isinstance(obj, datetime):

r = obj.strftime('D:%Y%m%d%H%M%S')

z = obj.utcoffset()

if z is not None:

z = z.seconds

else:

if time.daylight:

z = time.altzone

else:

z = time.timezone

if z == 0:

r += 'Z'

elif z < 0:

r += "+%02d'%02d'" % ((-z) // 3600, (-z) % 3600)

else:

r += "-%02d'%02d'" % (z // 3600, z % 3600)

return pdfRepr(r)

# A bounding box

elif isinstance(obj, BboxBase):

return fill([pdfRepr(val) for val in obj.bounds])

else:

msg = "Don't know a PDF representation for %s objects." % type(obj)

"""PDF reference object.

def __init__(self, id):

self.id = id

def __repr__(self):

return "<Reference %d>" % self.id

def pdfRepr(self):

return ("%d 0 R" % self.id).encode('ascii')

def write(self, contents, file):

write = file.write

write(("%d 0 obj\n" % self.id).encode('ascii'))

write(pdfRepr(contents))

"""PDF name object."""

__slots__ = ('name',)

_regex = re.compile(r'[^!-~]')

def __init__(self, name):

if isinstance(name, Name):

self.name = name.name

else:

if isinstance(name, bytes):

name = name.decode('ascii')

self.name = self._regex.sub(Name.hexify, name).encode('ascii')

def __repr__(self):

return "<Name %s>" % self.name

def __str__(self):

return '/' + six.text_type(self.name)

def __eq__(self, other):

return isinstance(other, Name) and self.name == other.name

def __lt__(self, other):

return isinstance(other, Name) and self.name < other.name

def __hash__(self):

return hash(self.name)

@staticmethod

def hexify(match):

return '#%02x' % ord(match.group())

def pdfRepr(self):

"""PDF operator object."""

__slots__ = ('op',)

def __init__(self, op):

self.op = op

def __repr__(self):

return '<Operator %s>' % self.op

def pdfRepr(self):

"""Store verbatim PDF command content for later inclusion in the

def __init__(self, x):

self._x = x

def pdfRepr(self):

close_fill_stroke=b'b', fill_stroke=b'B', fill=b'f', closepath=b'h',

close_stroke=b's', stroke=b'S', endpath=b'n', begin_text=b'BT',

end_text=b'ET', curveto=b'c', rectangle=b're', lineto=b'l', moveto=b'm',

concat_matrix=b'cm', use_xobject=b'Do', setgray_stroke=b'G',

setgray_nonstroke=b'g', setrgb_stroke=b'RG', setrgb_nonstroke=b'rg',

setcolorspace_stroke=b'CS', setcolorspace_nonstroke=b'cs',

setcolor_stroke=b'SCN', setcolor_nonstroke=b'scn', setdash=b'd',

setlinejoin=b'j', setlinecap=b'J', setgstate=b'gs', gsave=b'q',

grestore=b'Q', textpos=b'Td', selectfont=b'Tf', textmatrix=b'Tm',

"""Return the PDF operator to paint a path in the following way:

if stroke:

if fill:

return Op.fill_stroke

else:

return Op.stroke

else:

if fill:

return Op.fill

else:

"""PDF stream object.

__slots__ = ('id', 'len', 'pdfFile', 'file', 'compressobj', 'extra', 'pos')

def __init__(self, id, len, file, extra=None, png=None):

"""id: object id of stream; len: an unused Reference object for the

self.id = id # object id

self.len = len # id of length object

self.pdfFile = file

self.file = file.fh # file to which the stream is written

self.compressobj = None # compression object

if extra is None:

self.extra = dict()

else:

self.extra = extra.copy()

if png is not None:

self.extra.update({'Filter': Name('FlateDecode'),

'DecodeParms': png})

self.pdfFile.recordXref(self.id)

if rcParams['pdf.compression'] and not png:

self.compressobj = zlib.compressobj(rcParams['pdf.compression'])

if self.len is None:

self.file = BytesIO()

else:

self._writeHeader()

self.pos = self.file.tell()

def _writeHeader(self):

write = self.file.write

write(("%d 0 obj\n" % self.id).encode('ascii'))

dict = self.extra

dict['Length'] = self.len

if rcParams['pdf.compression']:

dict['Filter'] = Name('FlateDecode')

write(pdfRepr(dict))

write(b"\nstream\n")

def end(self):

"""Finalize stream."""

self._flush()

if self.len is None:

contents = self.file.getvalue()

self.len = len(contents)

self.file = self.pdfFile.fh

self._writeHeader()

self.file.write(contents)

self.file.write(b"\nendstream\nendobj\n")

else:

length = self.file.tell() - self.pos

self.file.write(b"\nendstream\nendobj\n")

self.pdfFile.writeObject(self.len, length)

def write(self, data):

"""Write some data on the stream."""

if self.compressobj is None:

self.file.write(data)

else:

compressed = self.compressobj.compress(data)

self.file.write(compressed)

def _flush(self):

"""Flush the compression object."""

if self.compressobj is not None:

compressed = self.compressobj.flush()

self.file.write(compressed)

"""PDF file object."""

def __init__(self, filename, metadata=None):

self.nextObject = 1 # next free object id

self.xrefTable = [[0, 65535, 'the zero object']]

self.passed_in_file_object = False

self.original_file_like = None

self.tell_base = 0

if isinstance(filename, six.string_types):

fh = open(filename, 'wb')

elif is_writable_file_like(filename):

try:

self.tell_base = filename.tell()

except IOError:

fh = BytesIO()

self.original_file_like = filename

else:

fh = filename

self.passed_in_file_object = True

else:

raise ValueError("filename must be a path or a file-like object")

self._core14fontdir = os.path.join(

rcParams['datapath'], 'fonts', 'pdfcorefonts')

self.fh = fh

self.currentstream = None # stream object to write to, if any

fh.write(b"%PDF-1.4\n") # 1.4 is the first version to have alpha

# Output some eight-bit chars as a comment so various utilities

# recognize the file as binary by looking at the first few

# lines (see note in section 3.4.1 of the PDF reference).

fh.write(b"%\254\334 \253\272\n")

self.rootObject = self.reserveObject('root')

self.pagesObject = self.reserveObject('pages')

self.pageList = []

self.fontObject = self.reserveObject('fonts')

self.alphaStateObject = self.reserveObject('extended graphics states')

self.hatchObject = self.reserveObject('tiling patterns')

self.gouraudObject = self.reserveObject('Gouraud triangles')

self.XObjectObject = self.reserveObject('external objects')

self.resourceObject = self.reserveObject('resources')

root = {'Type': Name('Catalog'),

'Pages': self.pagesObject}

self.writeObject(self.rootObject, root)

# get source date from SOURCE_DATE_EPOCH, if set

# See https://reproducible-builds.org/specs/source-date-epoch/

source_date_epoch = os.getenv("SOURCE_DATE_EPOCH")

if source_date_epoch:

source_date = datetime.utcfromtimestamp(int(source_date_epoch))

source_date = source_date.replace(tzinfo=UTC)

else:

source_date = datetime.today()

self.infoDict = {

'Creator': 'matplotlib %s, http://matplotlib.org' % __version__,

'Producer': 'matplotlib pdf backend %s' % __version__,

'CreationDate': source_date

}

if metadata is not None:

self.infoDict.update(metadata)

self.infoDict = {k: v for (k, v) in self.infoDict.items()

if v is not None}

self.fontNames = {} # maps filenames to internal font names

self.nextFont = 1 # next free internal font name

self.dviFontInfo = {} # maps dvi font names to embedding information

self._texFontMap = None # maps TeX font names to PostScript fonts

# differently encoded Type-1 fonts may share the same descriptor

self.type1Descriptors = {}

self.used_characters = {}

self.alphaStates = {} # maps alpha values to graphics state objects

self.nextAlphaState = 1

# reproducible writeHatches needs an ordered dict:

self.hatchPatterns = collections.OrderedDict()

self.nextHatch = 1

self.gouraudTriangles = []

self._images = collections.OrderedDict() # reproducible writeImages

self.nextImage = 1

self.markers = collections.OrderedDict() # reproducible writeMarkers

self.multi_byte_charprocs = {}

self.paths = []

self.pageAnnotations = [] # A list of annotations for the

# current page

# The PDF spec recommends to include every procset

procsets = [Name(x)

for x in "PDF Text ImageB ImageC ImageI".split()]

# Write resource dictionary.

# Possibly TODO: more general ExtGState (graphics state dictionaries)

# ColorSpace Pattern Shading Properties

resources = {'Font': self.fontObject,

'XObject': self.XObjectObject,

'ExtGState': self.alphaStateObject,

'Pattern': self.hatchObject,

'Shading': self.gouraudObject,

'ProcSet': procsets}

self.writeObject(self.resourceObject, resources)

def newPage(self, width, height):

self.endStream()

self.width, self.height = width, height

contentObject = self.reserveObject('page contents')

thePage = {'Type': Name('Page'),

'Parent': self.pagesObject,

'Resources': self.resourceObject,

'MediaBox': [0, 0, 72 * width, 72 * height],

'Contents': contentObject,

'Group': {'Type': Name('Group'),

'S': Name('Transparency'),

'CS': Name('DeviceRGB')},

'Annots': self.pageAnnotations,

}

pageObject = self.reserveObject('page')

self.writeObject(pageObject, thePage)

self.pageList.append(pageObject)

self.beginStream(contentObject.id,

self.reserveObject('length of content stream'))

# Initialize the pdf graphics state to match the default mpl

# graphics context: currently only the join style needs to be set

self.output(GraphicsContextPdf.joinstyles['round'], Op.setlinejoin)

# Clear the list of annotations for the next page

self.pageAnnotations = []

def newTextnote(self, text, positionRect=[-100, -100, 0, 0]):

# Create a new annotation of type text

theNote = {'Type': Name('Annot'),

'Subtype': Name('Text'),

'Contents': text,

'Rect': positionRect,

}

annotObject = self.reserveObject('annotation')

self.writeObject(annotObject, theNote)

self.pageAnnotations.append(annotObject)

def finalize(self):

"Write out the various deferred objects and the pdf end matter."

self.endStream()

self.writeFonts()

self.writeObject(

self.alphaStateObject,

{val[0]: val[1] for val in six.itervalues(self.alphaStates)})

self.writeHatches()

self.writeGouraudTriangles()

xobjects = {

name: ob for image, name, ob in six.itervalues(self._images)}

for tup in six.itervalues(self.markers):

xobjects[tup[0]] = tup[1]

for name, value in six.iteritems(self.multi_byte_charprocs):

xobjects[name] = value

for name, path, trans, ob, join, cap, padding, filled, stroked \

in self.paths:

xobjects[name] = ob

self.writeObject(self.XObjectObject, xobjects)

self.writeImages()

self.writeMarkers()

self.writePathCollectionTemplates()

self.writeObject(self.pagesObject,

{'Type': Name('Pages'),

'Kids': self.pageList,

'Count': len(self.pageList)})

self.writeInfoDict()

# Finalize the file

self.writeXref()

self.writeTrailer()

def close(self):

"Flush all buffers and free all resources."

self.endStream()

if self.passed_in_file_object:

self.fh.flush()

else:

if self.original_file_like is not None:

self.original_file_like.write(self.fh.getvalue())

self.fh.close()

def write(self, data):

if self.currentstream is None:

self.fh.write(data)

else:

self.currentstream.write(data)

def output(self, *data):

self.write(fill([pdfRepr(x) for x in data]))

self.write(b'\n')

def beginStream(self, id, len, extra=None, png=None):

assert self.currentstream is None

self.currentstream = Stream(id, len, self, extra, png)

def endStream(self):

if self.currentstream is not None:

self.currentstream.end()

self.currentstream = None

def fontName(self, fontprop):

"""

if isinstance(fontprop, six.string_types):

filename = fontprop

elif rcParams['pdf.use14corefonts']:

filename = findfont(

fontprop, fontext='afm', directory=self._core14fontdir)

if filename is None:

filename = findfont(

"Helvetica", fontext='afm', directory=self._core14fontdir)

else:

filename = findfont(fontprop)

Fx = self.fontNames.get(filename)

if Fx is None:

Fx = Name('F%d' % self.nextFont)

self.fontNames[filename] = Fx

self.nextFont += 1

matplotlib.verbose.report(

'Assigning font %s = %r' % (Fx, filename),

'debug')

return Fx

@property

def texFontMap(self):

# lazy-load texFontMap, it takes a while to parse

# and usetex is a relatively rare use case

if self._texFontMap is None:

self._texFontMap = dviread.PsfontsMap(

dviread.find_tex_file('pdftex.map'))

return self._texFontMap

def dviFontName(self, dvifont):

"""

dvi_info = self.dviFontInfo.get(dvifont.texname)

if dvi_info is not None:

return dvi_info.pdfname

psfont = self.texFontMap[dvifont.texname]

if psfont.filename is None:

raise ValueError(

("No usable font file found for {0} (TeX: {1}). "

"The font may lack a Type-1 version.")

.format(psfont.psname, dvifont.texname))

pdfname = Name('F%d' % self.nextFont)

self.nextFont += 1

matplotlib.verbose.report(

'Assigning font {0} = {1} (dvi)'.format(pdfname, dvifont.texname),

'debug')

self.dviFontInfo[dvifont.texname] = Bunch(

dvifont=dvifont,

pdfname=pdfname,

fontfile=psfont.filename,

basefont=psfont.psname,

encodingfile=psfont.encoding,

effects=psfont.effects)

return pdfname

def writeFonts(self):

fonts = {}

for dviname, info in sorted(self.dviFontInfo.items()):

Fx = info.pdfname

matplotlib.verbose.report('Embedding Type-1 font %s from dvi'

% dviname, 'debug')

fonts[Fx] = self._embedTeXFont(info)

for filename in sorted(self.fontNames):

Fx = self.fontNames[filename]

matplotlib.verbose.report('Embedding font %s' % filename, 'debug')

if filename.endswith('.afm'):

# from pdf.use14corefonts

matplotlib.verbose.report('Writing AFM font', 'debug')

fonts[Fx] = self._write_afm_font(filename)

else:

# a normal TrueType font

matplotlib.verbose.report('Writing TrueType font', 'debug')

realpath, stat_key = get_realpath_and_stat(filename)

chars = self.used_characters.get(stat_key)

if chars is not None and len(chars[1]):

fonts[Fx] = self.embedTTF(realpath, chars[1])

self.writeObject(self.fontObject, fonts)

def _write_afm_font(self, filename):

with open(filename, 'rb') as fh:

font = AFM(fh)

fontname = font.get_fontname()

fontdict = {'Type': Name('Font'),

'Subtype': Name('Type1'),

'BaseFont': Name(fontname),

'Encoding': Name('WinAnsiEncoding')}

fontdictObject = self.reserveObject('font dictionary')

self.writeObject(fontdictObject, fontdict)

return fontdictObject

def _embedTeXFont(self, fontinfo):

msg = ('Embedding TeX font {0} - fontinfo={1}'

.format(fontinfo.dvifont.texname, fontinfo.__dict__))

matplotlib.verbose.report(msg, 'debug')

# Widths

widthsObject = self.reserveObject('font widths')

self.writeObject(widthsObject, fontinfo.dvifont.widths)

# Font dictionary

fontdictObject = self.reserveObject('font dictionary')

fontdict = {

'Type': Name('Font'),

'Subtype': Name('Type1'),

'FirstChar': 0,

'LastChar': len(fontinfo.dvifont.widths) - 1,

'Widths': widthsObject,

}

# Encoding (if needed)

if fontinfo.encodingfile is not None:

enc = dviread.Encoding(fontinfo.encodingfile)

differencesArray = [Name(ch) for ch in enc]

differencesArray = [0] + differencesArray

fontdict['Encoding'] = \

{'Type': Name('Encoding'),

'Differences': differencesArray}

# If no file is specified, stop short

if fontinfo.fontfile is None:

msg = ('Because of TeX configuration (pdftex.map, see updmap '

'option pdftexDownloadBase14) the font {0} is not '

'embedded. This is deprecated as of PDF 1.5 and it may '

'cause the consumer application to show something that '

'was not intended.').format(fontinfo.basefont)

warnings.warn(msg)

fontdict['BaseFont'] = Name(fontinfo.basefont)

self.writeObject(fontdictObject, fontdict)

return fontdictObject

# We have a font file to embed - read it in and apply any effects

t1font = type1font.Type1Font(fontinfo.fontfile)

if fontinfo.effects:

t1font = t1font.transform(fontinfo.effects)

fontdict['BaseFont'] = Name(t1font.prop['FontName'])

# Font descriptors may be shared between differently encoded

# Type-1 fonts, so only create a new descriptor if there is no

# existing descriptor for this font.

effects = (fontinfo.effects.get('slant', 0.0),

fontinfo.effects.get('extend', 1.0))

fontdesc = self.type1Descriptors.get((fontinfo.fontfile, effects))

if fontdesc is None:

fontdesc = self.createType1Descriptor(t1font, fontinfo.fontfile)

self.type1Descriptors[(fontinfo.fontfile, effects)] = fontdesc

fontdict['FontDescriptor'] = fontdesc

self.writeObject(fontdictObject, fontdict)

return fontdictObject

def createType1Descriptor(self, t1font, fontfile):

# Create and write the font descriptor and the font file

# of a Type-1 font

fontdescObject = self.reserveObject('font descriptor')

fontfileObject = self.reserveObject('font file')

italic_angle = t1font.prop['ItalicAngle']

fixed_pitch = t1font.prop['isFixedPitch']

flags = 0

# fixed width

if fixed_pitch:

flags |= 1 << 0

# TODO: serif

if 0:

flags |= 1 << 1

# TODO: symbolic (most TeX fonts are)

if 1:

flags |= 1 << 2

# non-symbolic

else:

flags |= 1 << 5

# italic

if italic_angle:

flags |= 1 << 6

# TODO: all caps

if 0:

flags |= 1 << 16

# TODO: small caps

if 0:

flags |= 1 << 17

# TODO: force bold

if 0:

flags |= 1 << 18

ft2font = get_font(fontfile)

descriptor = {

'Type': Name('FontDescriptor'),

'FontName': Name(t1font.prop['FontName']),

'Flags': flags,

'FontBBox': ft2font.bbox,

'ItalicAngle': italic_angle,

'Ascent': ft2font.ascender,

'Descent': ft2font.descender,

'CapHeight': 1000, # TODO: find this out

'XHeight': 500, # TODO: this one too

'FontFile': fontfileObject,

'FontFamily': t1font.prop['FamilyName'],

'StemV': 50, # TODO

# (see also revision 3874; but not all TeX distros have AFM files!)

# 'FontWeight': a number where 400 = Regular, 700 = Bold

}

self.writeObject(fontdescObject, descriptor)

self.beginStream(fontfileObject.id, None,

{'Length1': len(t1font.parts[0]),

'Length2': len(t1font.parts[1]),

'Length3': 0})

self.currentstream.write(t1font.parts[0])

self.currentstream.write(t1font.parts[1])

self.endStream()

return fontdescObject

def _get_xobject_symbol_name(self, filename, symbol_name):

return "%s-%s" % (

os.path.splitext(os.path.basename(filename))[0],

symbol_name)

_identityToUnicodeCMap = """/CIDInit /ProcSet findresource begin

def embedTTF(self, filename, characters):

"""Embed the TTF font from the named file into the document."""

font = get_font(filename)

fonttype = rcParams['pdf.fonttype']

def cvt(length, upe=font.units_per_EM, nearest=True):

"Convert font coordinates to PDF glyph coordinates"

value = length / upe * 1000

if nearest:

return np.round(value)

# Perhaps best to round away from zero for bounding

# boxes and the like

if value < 0:

return floor(value)

else:

return ceil(value)

def embedTTFType3(font, characters, descriptor):

"""The Type 3-specific part of embedding a Truetype font"""

widthsObject = self.reserveObject('font widths')

fontdescObject = self.reserveObject('font descriptor')

fontdictObject = self.reserveObject('font dictionary')

charprocsObject = self.reserveObject('character procs')

differencesArray = []

firstchar, lastchar = 0, 255

bbox = [cvt(x, nearest=False) for x in font.bbox]

fontdict = {

'Type': Name('Font'),

'BaseFont': ps_name,

'FirstChar': firstchar,

'LastChar': lastchar,

'FontDescriptor': fontdescObject,

'Subtype': Name('Type3'),

'Name': descriptor['FontName'],

'FontBBox': bbox,

'FontMatrix': [.001, 0, 0, .001, 0, 0],

'CharProcs': charprocsObject,

'Encoding': {

'Type': Name('Encoding'),

'Differences': differencesArray},

'Widths': widthsObject

}

# Make the "Widths" array

from encodings import cp1252

# The "decoding_map" was changed

# to a "decoding_table" as of Python 2.5.

if hasattr(cp1252, 'decoding_map'):

def decode_char(charcode):

return cp1252.decoding_map[charcode] or 0

else:

def decode_char(charcode):

return ord(cp1252.decoding_table[charcode])

def get_char_width(charcode):

s = decode_char(charcode)

width = font.load_char(

s, flags=LOAD_NO_SCALE | LOAD_NO_HINTING).horiAdvance

return cvt(width)

widths = [get_char_width(charcode)

for charcode in range(firstchar, lastchar+1)]

descriptor['MaxWidth'] = max(widths)

# Make the "Differences" array, sort the ccodes < 255 from

# the multi-byte ccodes, and build the whole set of glyph ids

# that we need from this font.

glyph_ids = []

differences = []

multi_byte_chars = set()

for c in characters:

ccode = c

gind = font.get_char_index(ccode)

glyph_ids.append(gind)

glyph_name = font.get_glyph_name(gind)

if ccode <= 255:

differences.append((ccode, glyph_name))

else:

multi_byte_chars.add(glyph_name)

differences.sort()

last_c = -2

for c, name in differences:

if c != last_c + 1:

differencesArray.append(c)

differencesArray.append(Name(name))

last_c = c

# Make the charprocs array (using ttconv to generate the

# actual outlines)

rawcharprocs = ttconv.get_pdf_charprocs(

filename.encode(sys.getfilesystemencoding()), glyph_ids)

charprocs = {}

for charname in sorted(rawcharprocs):

stream = rawcharprocs[charname]

charprocDict = {'Length': len(stream)}

# The 2-byte characters are used as XObjects, so they

# need extra info in their dictionary

if charname in multi_byte_chars:

charprocDict['Type'] = Name('XObject')

charprocDict['Subtype'] = Name('Form')

charprocDict['BBox'] = bbox

# Each glyph includes bounding box information,

# but xpdf and ghostscript can't handle it in a