widthsObject=self.reserveObject('font widths')

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

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

fontdictObject=self.reserveObject('font dictionary')

frommatplotlibimport_api,cbook

frommatplotlibimport_api,cbook,textpath

frommatplotlib.ft2fontimportFT2Font,LoadFlags

_log=logging.getLogger(__name__)

defglyph_name_or_index(self):

entry=self._get_pdftexmap_entry()

return (_parse_enc(entry.encoding)[self.glyph]

ifentry.encodingisnotNoneelseself.glyph)

scale=font._scale

forx,y,f,g,winfont._vf[char].text:

newf=DviFont(scale=_mul2012(scale,f._scale),

tfm=f._tfm,texname=f.texname,vf=f._vf)

metrics=f._metrics,texname=f.texname,vf=f._vf)

self.text.append(Text(self.h+_mul2012(x,scale),

self.v+_mul2012(y,scale),

newf,g,newf._width_of(g)))

def_fnt_def_real(self,k,c,s,d,a,l):

n=self.file.read(a+l)

fontname=n[-l:].decode('ascii')

iffontname.startswith('[')andfontname.endswith(']'):

metrics=TtfMetrics(fontname[1:-1])

self.fonts[k]=DviFont(scale=s,metrics=metrics,texname=n,vf=None)

try:

tfm=_tfmfile(fontname)

exceptFileNotFoundErrorasexc:

vf=_vffile(fontname)

exceptFileNotFoundError:

self.fonts[k]=DviFont(scale=s,tfm=tfm,texname=n,vf=vf)

self.fonts[k]=DviFont(scale=s,metrics=tfm,texname=n,vf=vf)

def_pre(self,i,num,den,mag,k):

__slots__= ('texname','size','widths','_scale','_vf','_tfm')

__slots__= ('texname','size','_scale','_vf','_metrics')

def__init__(self,scale,tfm,texname,vf):

def__init__(self,scale,metrics,texname,vf):

_api.check_isinstance(bytes,texname=texname)

self._scale=scale

self._tfm=tfm

self._metrics=metrics

self.texname=texname

self._vf=vf

self.size=scale* (72.0/ (72.27*2**16))

try:

nchars=max(tfm.width)+1

exceptValueError:

self.widths= [(1000*tfm.width.get(char,0))>>20

forcharinrange(nchars)]

widths=_api.deprecated("3.11")(property(lambdaself: ...))

def__eq__(self,other):

return (type(self)istype(other)

def_width_of(self,char):

width=self._tfm.width.get(char,None)

ifwidthisnotNone:

return_mul2012(width,self._scale)

metrics=self._metrics.get_metrics(char)

ifmetricsisNone:

_log.debug('Nowidth for char %d in font %s.',char,self.texname)

def_height_depth_of(self,char):

result= []

formetric,namein ((self._tfm.height,"height"),

(self._tfm.depth,"depth")):

value=metric.get(char,None)

ifvalueisNone:

_log.debug('No %s for char %d in font %s',

name,char,self.texname)

result.append(0)

else:

result.append(_mul2012(value,self._scale))

metrics=self._metrics.get_metrics(char)

ifmetricsisNone:

_log.debug('No metrics for char %d in font %s',char,self.texname)

return [0,0]

metrics= [

_mul2012(metrics.height,self._scale),

_mul2012(metrics.depth,self._scale),

]

ifre.match(br'^cmsy\d+$',self.texname)andchar==0:

result[-1]=0

metrics[-1]=0

classVf(Dvi):

return (num1*num2)>>20

WHD=namedtuple('WHD','width height depth')

classTfm:

__slots__= ('checksum','design_size','width','height','depth')

__slots__= ('checksum','design_size','_whds','widths')

def__init__(self,filename):

_log.debug('opening tfm file %s',filename)

widths=struct.unpack(f'!{nw}i',file.read(4*nw))

heights=struct.unpack(f'!{nh}i',file.read(4*nh))

depths=struct.unpack(f'!{nd}i',file.read(4*nd))

self.width= {}

self.height= {}

self.depth= {}

self._whds= {}

foridx,charinenumerate(range(bc,ec+1)):

byte0=char_info[4*idx]

byte1=char_info[4*idx+1]

self.width[char]=widths[byte0]

self.height[char]=heights[byte1>>4]

self.depth[char]=depths[byte1&0xf]

self._whds[char]=WHD(

widths[byte0],heights[byte1>>4],depths[byte1&0xf])

self.widths= [(1000*self._whds[c].widthifcinself._whdselse0)>>20

forcinrange(max(self._whds))]ifself._whdselse []

defget_metrics(self,char):

returnself._whds[char]

width=_api.deprecated("3.11")(

property(lambdaself: {c:m.widthforc,minself._whds}))

height=_api.deprecated("3.11")(

property(lambdaself: {c:m.heightforc,minself._whds}))

depth=_api.deprecated("3.11")(

property(lambdaself: {c:m.depthforc,minself._whds}))

classTtfMetrics:

def__init__(self,filename):

self._face=FT2Font(filename,hinting_factor=1)# Manage closing?

defget_metrics(self,char):

mul=self._face.units_per_EM

g=self._face.load_glyph(char,LoadFlags.NO_SCALE)

returnWHD(g.horiAdvance*mul,

g.height*mul,

(g.height-g.horiBearingY)*mul)

PsFont=namedtuple('PsFont','texname psname effects encoding filename')

no_comments=re.sub("%.*","",Path(path).read_text(encoding="ascii"))

array=re.search(r"(?s)\[(.*)\]",no_comments).group(1)

importfontTools.agl

parser=ArgumentParser()

parser.add_argument("filename")

parser.add_argument("dpi",nargs="?",type=float,default=None)

args=parser.parse_args()

withDvi(args.filename,args.dpi)asdvi:

fontmap=PsfontsMap(find_tex_file('pdftex.map'))

forpageindvi:

print(f"===new page === "

print(f"===NEW PAGE === "

f"(w:{page.width}, h:{page.height}, d:{page.descent})")

forfont,groupinitertools.groupby(

page.text,lambdatext:text.font):

print(f"font:{font.texname.decode('latin-1')!r}\t"

f"scale:{font._scale/2**20}")

print("x","y","glyph","chr","w","(glyphs)",sep="\t")

print("--- GLYPHS ---")

forfont,groupinitertools.groupby(page.text,lambdatext:text.font):

font_name=font.texname.decode("latin-1")

filename= (font_name[1:-1]iffont_name.startswith("[")

elsefontmap[font.texname].filename)

iffont_name.startswith("["):

print(f"font:{font_name}")

else:

print(f"font:{font_name} at{filename}")

print(f"scale:{font._scale/2**20}")

print(" ".join(map("{:>11}".format, ["x","y","glyph","chr","w"])))

face=FT2Font(filename)

fortextingroup:

print(text.x,text.y,text.glyph,

chr(text.glyph)ifchr(text.glyph).isprintable()

else".",

text.width,sep="\t")

iffont_name.startswith("["):

glyph_name=face.get_glyph_name(text.glyph)

else:

ifisinstance(text.glyph_name_or_index,str):

glyph_name=text.glyph_name_or_index

else:

textpath.TextToPath._select_native_charmap(face)

glyph_name=face.get_glyph_name(

face.get_char_index(text.glyph))

glyph_str=fontTools.agl.toUnicode(glyph_name)

print(" ".join(map("{:>11}".format, [

text.x,text.y,text.glyph,glyph_str,text.width])))

ifpage.boxes:

print("x","y","h","w","","(boxes)",sep="\t")

print("--- BOXES ---")

print(" ".join(map("{:>11}".format, ["x","y","h","w"])))

forboxinpage.boxes:

print(box.x,box.y,box.height,box.width,sep="\t")

print(" ".join(map("{:>11}".format, [

box.x,box.y,box.height,box.width])))

# zapf chancery, charter, serif, sans-serif, helvetica,

# avant garde, courier, monospace, computer modern roman,

# computer modern sans serif, computer modern typewriter

#text.latex.engine: latex

#text.latex.preamble: # IMPROPER USE OF THIS FEATURE WILL LEAD TO LATEX FAILURES

# AND IS THEREFORE UNSUPPORTED. PLEASE DO NOT ASK FOR HELP

# IF THIS FEATURE DOES NOT DO WHAT YOU EXPECT IT TO.

"text.color":validate_color,

"text.usetex":validate_bool,

"text.latex.engine": ["latex","lualatex"],

"text.latex.preamble":validate_string,

"text.hinting": ["default","no_autohint","force_autohint",

"no_hinting","auto","native","either","none"],