pyx/dvifile.py

   1 #!/usr/bin/env python
   2 # -*- coding: ISO-8859-1 -*-
   3 #
   4 #
   5 # Copyright (C) 2002-2005 Jörg Lehmann <joergl@users.sourceforge.net>
   6 # Copyright (C) 2003-2004 Michael Schindler <m-schindler@users.sourceforge.net>
   7 # Copyright (C) 2002-2005 André Wobst <wobsta@users.sourceforge.net>
   8 #
   9 # This file is part of PyX (http://pyx.sourceforge.net/).
  10 #
  11 # PyX is free software; you can redistribute it and/or modify
  12 # it under the terms of the GNU General Public License as published by
  13 # the Free Software Foundation; either version 2 of the License, or
  14 # (at your option) any later version.
  15 #
  16 # PyX is distributed in the hope that it will be useful,
  17 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  18 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19 # GNU General Public License for more details.
  20 #
  21 # You should have received a copy of the GNU General Public License
  22 # along with PyX; if not, write to the Free Software
  23 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
  24
  25 import cStringIO, exceptions, re, struct, string, sys, warnings, math
  26 import unit, epsfile, bbox, canvas, color, trafo, path, pykpathsea, type1font
  27
  28
  29 class binfile:
  30
  31     def __init__(self, filename, mode="r"):
  32         self.file = open(filename, mode)
  33
  34     def close(self):
  35         self.file.close()
  36
  37     def tell(self):
  38         return self.file.tell()
  39
  40     def eof(self):
  41         return self.file.eof()
  42
  43     def read(self, bytes):
  44         return self.file.read(bytes)
  45
  46     def readint(self, bytes=4, signed=0):
  47         first = 1
  48         result = 0
  49         while bytes:
  50             value = ord(self.file.read(1))
  51             if first and signed and value > 127:
  52                 value -= 256
  53             first = 0
  54             result = 256 * result + value
  55             bytes -= 1
  56         return result
  57
  58     def readint32(self):
  59         return struct.unpack(">l", self.file.read(4))[0]
  60
  61     def readuint32(self):
  62         return struct.unpack(">L", self.file.read(4))[0]
  63
  64     def readint24(self):
  65         # XXX: checkme
  66         return struct.unpack(">l", "\0"+self.file.read(3))[0]
  67
  68     def readuint24(self):
  69         # XXX: checkme
  70         return struct.unpack(">L", "\0"+self.file.read(3))[0]
  71
  72     def readint16(self):
  73         return struct.unpack(">h", self.file.read(2))[0]
  74
  75     def readuint16(self):
  76         return struct.unpack(">H", self.file.read(2))[0]
  77
  78     def readchar(self):
  79         return struct.unpack("b", self.file.read(1))[0]
  80
  81     def readuchar(self):
  82         return struct.unpack("B", self.file.read(1))[0]
  83
  84     def readstring(self, bytes):
  85         l = self.readuchar()
  86         assert l <= bytes-1, "inconsistency in file: string too long"
  87         return self.file.read(bytes-1)[:l]
  88
  89 class stringbinfile(binfile):
  90
  91     def __init__(self, s):
  92         self.file = cStringIO.StringIO(s)
  93
  94
  95
  96
  97 ##############################################################################
  98 # TFM file handling
  99 ##############################################################################
 100
 101 class TFMError(exceptions.Exception): pass
 102
 103
 104 class char_info_word:
 105     def __init__(self, word):
 106         self.width_index  = int((word & 0xFF000000L) >> 24) #make sign-safe
 107         self.height_index = (word & 0x00F00000) >> 20
 108         self.depth_index  = (word & 0x000F0000) >> 16
 109         self.italic_index = (word & 0x0000FC00) >> 10
 110         self.tag          = (word & 0x00000300) >> 8
 111         self.remainder    = (word & 0x000000FF)
 112
 113
 114 class tfmfile:
 115     def __init__(self, name, debug=0):
 116         self.file = binfile(name, "rb")
 117
 118         #
 119         # read pre header
 120         #
 121
 122         self.lf = self.file.readint16()
 123         self.lh = self.file.readint16()
 124         self.bc = self.file.readint16()
 125         self.ec = self.file.readint16()
 126         self.nw = self.file.readint16()
 127         self.nh = self.file.readint16()
 128         self.nd = self.file.readint16()
 129         self.ni = self.file.readint16()
 130         self.nl = self.file.readint16()
 131         self.nk = self.file.readint16()
 132         self.ne = self.file.readint16()
 133         self.np = self.file.readint16()
 134
 135         if not (self.bc-1 <= self.ec <= 255 and
 136                 self.ne <= 256 and
 137                 self.lf == 6+self.lh+(self.ec-self.bc+1)+self.nw+self.nh+self.nd
 138                 +self.ni+self.nl+self.nk+self.ne+self.np):
 139             raise TFMError, "error in TFM pre-header"
 140
 141         if debug:
 142             print "lh=%d" % self.lh
 143
 144         #
 145         # read header
 146         #
 147
 148         self.checksum = self.file.readint32()
 149         self.designsize = self.file.readint32()
 150         assert self.designsize > 0, "invald design size"
 151         if self.lh > 2:
 152             assert self.lh > 11, "inconsistency in TFM file: incomplete field"
 153             self.charcoding = self.file.readstring(40)
 154         else:
 155             self.charcoding = None
 156
 157         if self.lh > 12:
 158             assert self.lh > 16, "inconsistency in TFM file: incomplete field"
 159             self.fontfamily = self.file.readstring(20)
 160         else:
 161             self.fontfamily = None
 162
 163         if debug:
 164             print "(FAMILY %s)" % self.fontfamily
 165             print "(CODINGSCHEME %s)" % self.charcoding
 166             print "(DESINGSIZE R %f)" % 16.0*self.designsize/16777216L
 167
 168         if self.lh > 17:
 169             self.sevenbitsave = self.file.readuchar()
 170             # ignore the following two bytes
 171             self.file.readint16()
 172             facechar = self.file.readuchar()
 173             # decode ugly face specification into the Knuth suggested string
 174             if facechar < 18:
 175                 if facechar >= 12:
 176                     self.face = "E"
 177                     facechar -= 12
 178                 elif facechar >= 6:
 179                     self.face = "C"
 180                     facechar -= 6
 181                 else:
 182                     self.face = "R"
 183
 184                 if facechar >= 4:
 185                     self.face = "L" + self.face
 186                     facechar -= 4
 187                 elif facechar >= 2:
 188                     self.face = "B" + self.face
 189                     facechar -= 2
 190                 else:
 191                     self.face = "M" + self.face
 192
 193                 if facechar == 1:
 194                     self.face = self.face[0] + "I" + self.face[1]
 195                 else:
 196                     self.face = self.face[0] + "R" + self.face[1]
 197
 198             else:
 199                 self.face = None
 200         else:
 201             self.sevenbitsave = self.face = None
 202
 203         if self.lh > 18:
 204             # just ignore the rest
 205             print self.file.read((self.lh-18)*4)
 206
 207         #
 208         # read char_info
 209         #
 210
 211         self.char_info = [None]*(self.ec+1)
 212         for charcode in range(self.bc, self.ec+1):
 213             self.char_info[charcode] = char_info_word(self.file.readint32())
 214             if self.char_info[charcode].width_index == 0:
 215                 # disable character if width_index is zero
 216                 self.char_info[charcode] = None
 217
 218         #
 219         # read widths
 220         #
 221
 222         self.width = [None for width_index in range(self.nw)]
 223         for width_index in range(self.nw):
 224             self.width[width_index] = self.file.readint32()
 225
 226         #
 227         # read heights
 228         #
 229
 230         self.height = [None for height_index in range(self.nh)]
 231         for height_index in range(self.nh):
 232             self.height[height_index] = self.file.readint32()
 233
 234         #
 235         # read depths
 236         #
 237
 238         self.depth = [None for depth_index in range(self.nd)]
 239         for depth_index in range(self.nd):
 240             self.depth[depth_index] = self.file.readint32()
 241
 242         #
 243         # read italic
 244         #
 245
 246         self.italic = [None for italic_index in range(self.ni)]
 247         for italic_index in range(self.ni):
 248             self.italic[italic_index] = self.file.readint32()
 249
 250         #
 251         # read lig_kern
 252         #
 253
 254         # XXX decode to lig_kern_command
 255
 256         self.lig_kern = [None for lig_kern_index in range(self.nl)]
 257         for lig_kern_index in range(self.nl):
 258             self.lig_kern[lig_kern_index] = self.file.readint32()
 259
 260         #
 261         # read kern
 262         #
 263
 264         self.kern = [None for kern_index in range(self.nk)]
 265         for kern_index in range(self.nk):
 266             self.kern[kern_index] = self.file.readint32()
 267
 268         #
 269         # read exten
 270         #
 271
 272         # XXX decode to extensible_recipe
 273
 274         self.exten = [None for exten_index in range(self.ne)]
 275         for exten_index in range(self.ne):
 276             self.exten[exten_index] = self.file.readint32()
 277
 278         #
 279         # read param
 280         #
 281
 282         # XXX decode
 283
 284         self.param = [None for param_index in range(self.np)]
 285         for param_index in range(self.np):
 286             self.param[param_index] = self.file.readint32()
 287
 288         self.file.close()
 289
 290
 291
 292 ##############################################################################
 293 # Font handling
 294 ##############################################################################
 295
 296 #
 297 # PostScript font selection and output primitives
 298 #
 299
 300 class UnsupportedFontFormat(Exception):
 301     pass
 302
 303 class UnsupportedPSFragment(Exception):
 304     pass
 305
 306 class fontmapping:
 307
 308     tokenpattern = re.compile(r'"(.*?)("\s+|"$|$)|(.*?)(\s+|$)')
 309
 310     def __init__(self, s):
 311         """ construct font mapping from line s of font mapping file """
 312         self.texname = self.basepsname = self.fontfile = None
 313
 314         # standard encoding
 315         self.encodingfile = None
 316
 317         # supported postscript fragments occuring in psfonts.map
 318         self.reencodefont = self.extendfont = self.slantfont = None
 319
 320         tokens = []
 321         while len(s):
 322             match = self.tokenpattern.match(s)
 323             if match:
 324                 if match.groups()[0] is not None:
 325                     tokens.append('"%s"' % match.groups()[0])
 326                 else:
 327                     tokens.append(match.groups()[2])
 328                 s = s[match.end():]
 329             else:
 330                 raise RuntimeError("wrong syntax")
 331
 332         for token in tokens:
 333             if token.startswith("<"):
 334                 if token.startswith("<<"):
 335                     # XXX: support non-partial download here
 336                     self.fontfile = token[2:]
 337                 elif token.startswith("<["):
 338                     self.encodingfile = token[2:]
 339                 elif token.endswith(".pfa") or token.endswith(".pfb"):
 340                     self.fontfile = token[1:]
 341                 elif token.endswith(".enc"):
 342                     self.encodingfile = token[1:]
 343                 elif token.endswith(".ttf"):
 344                     raise UnsupportedFontFormat("TrueType font")
 345                 else:
 346                     raise RuntimeError("wrong syntax")
 347             elif token.startswith('"'):
 348                 pscode = token[1:-1].split()
 349                 # parse standard postscript code fragments
 350                 while pscode:
 351                     try:
 352                         arg, cmd = pscode[:2]
 353                     except:
 354                         raise UnsupportedPSFragment("Unsupported Postscript fragment '%s'" % pscode)
 355                     pscode = pscode[2:]
 356                     if cmd == "ReEncodeFont":
 357                         self.reencodefont = arg
 358                     elif cmd == "ExtendFont":
 359                         self.extendfont = arg
 360                     elif cmd == "SlantFont":
 361                         self.slantfont = arg
 362                     else:
 363                         raise UnsupportedPSFragment("Unsupported Postscript fragment '%s %s'" % (arg, cmd))
 364             else:
 365                 if self.texname is None:
 366                     self.texname = token
 367                 else:
 368                     self.basepsname = token
 369         if self.basepsname is None:
 370             self.basepsname = self.texname
 371
 372     def __str__(self):
 373         return ("'%s' is '%s' read from '%s' encoded as '%s'" %
 374                 (self.texname, self.basepsname, self.fontfile, repr(self.encodingfile)))
 375
 376 # generate fontmap
 377
 378 def readfontmap(filenames):
 379     """ read font map from filename (without path) """
 380     fontmap = {}
 381     for filename in filenames:
 382         mappath = pykpathsea.find_file(filename, pykpathsea.kpse_fontmap_format)
 383         # try also the oft-used registration as dvips config file
 384         if not mappath:
 385             mappath = pykpathsea.find_file(filename, pykpathsea.kpse_dvips_config_format)
 386         if not mappath:
 387             raise RuntimeError("cannot find font mapping file '%s'" % filename)
 388         mapfile = open(mappath, "r")
 389         lineno = 0
 390         for line in mapfile.readlines():
 391             lineno += 1
 392             line = line.rstrip()
 393             if not (line=="" or line[0] in (" ", "%", "*", ";" , "#")):
 394                 try:
 395                     fm = fontmapping(line)
 396                 except (RuntimeError, UnsupportedPSFragment), e:
 397                     warnings.warn("Ignoring line %i in mapping file '%s': %s" % (lineno, filename, e))
 398                 except UnsupportedFontFormat, e:
 399                     pass
 400                 else:
 401                     fontmap[fm.texname] = fm
 402         mapfile.close()
 403     return fontmap
 404
 405
 406 class font:
 407
 408     def __init__(self, name, c, q, d, tfmconv, pyxconv, fontmap, debug=0):
 409         self.name = name
 410         self.q = q                  # desired size of font (fix_word) in TeX points
 411         self.d = d                  # design size of font (fix_word) in TeX points
 412         self.tfmconv = tfmconv      # conversion factor from tfm units to dvi units
 413         self.pyxconv = pyxconv      # conversion factor from dvi units to PostScript points
 414         self.fontmap = fontmap
 415         tfmpath = pykpathsea.find_file("%s.tfm" % self.name, pykpathsea.kpse_tfm_format)
 416         if not tfmpath:
 417             raise TFMError("cannot find %s.tfm" % self.name)
 418         self.tfmfile = tfmfile(tfmpath, debug)
 419
 420         # We only check for equality of font checksums if none of them
 421         # is zero. The case c == 0 happend in some VF files and
 422         # according to the VFtoVP documentation, paragraph 40, a check
 423         # is only performed if tfmfile.checksum > 0. Anyhow, being
 424         # more generous here seems to be reasonable
 425         if self.tfmfile.checksum != c and self.tfmfile.checksum != 0 and c != 0:
 426             raise DVIError("check sums do not agree: %d vs. %d" %
 427                            (self.tfmfile.checksum, c))
 428
 429         # Check whether the given design size matches the one defined in the tfm file
 430         if abs(self.tfmfile.designsize - d) > 2:
 431             raise DVIError("design sizes do not agree: %d vs. %d" % (self.tfmfile.designsize, d))
 432         #if q < 0 or q > 134217728:
 433         #    raise DVIError("font '%s' not loaded: bad scale" % self.name)
 434         if d < 0 or d > 134217728:
 435             raise DVIError("font '%s' not loaded: bad design size" % self.name)
 436
 437         self.scale = 1.0*q/d
 438
 439     def fontinfo(self):
 440         class fontinfo:
 441             pass
 442
 443         # The following code is a very crude way to obtain the information
 444         # required for the PDF font descritor. (TODO: The correct way would
 445         # be to read the information from the AFM file.)
 446         fontinfo = fontinfo()
 447         try:
 448             fontinfo.fontbbox = (0,
 449                                  -self.getdepth_ds(ord("y")),
 450                                  self.getwidth_ds(ord("W")),
 451                                  self.getheight_ds(ord("H")))
 452         except:
 453             fontinfo.fontbbox = (0, -10, 100, 100)
 454         try:
 455             fontinfo.italicangle = -180/math.pi*math.atan(self.tfmfile.param[0]/65536.0)
 456         except IndexError:
 457             fontinfo.italicangle = 0
 458         fontinfo.ascent = fontinfo.fontbbox[3]
 459         fontinfo.descent = fontinfo.fontbbox[1]
 460         try:
 461             fontinfo.capheight = self.getheight_ds(ord("h"))
 462         except:
 463             fontinfo.capheight = 100
 464         try:
 465             fontinfo.vstem = self.getwidth_ds(ord("."))/3
 466         except:
 467             fontinfo.vstem = 5
 468         return fontinfo
 469
 470     def __str__(self):
 471         return "font %s designed at %g TeX pts used at %g TeX pts" % (self.name,
 472                                                                       16.0*self.d/16777216L,
 473                                                                       16.0*self.q/16777216L)
 474     __repr__ = __str__
 475
 476     def getsize_pt(self):
 477         """ return size of font in (PS) points """
 478         # The factor 16L/16777216L=2**(-20) converts a fix_word (here self.q)
 479         # to the corresponding float. Furthermore, we have to convert from TeX
 480         # points to points, hence the factor 72/72.27.
 481         return 16L*self.q/16777216L*72/72.27
 482
 483     def _convert_tfm_to_dvi(self, length):
 484         # doing the integer math with long integers will lead to different roundings
 485         # return 16*length*int(round(self.q*self.tfmconv))/16777216
 486
 487         # Knuth instead suggests the following algorithm based on 4 byte integer logic only
 488         # z = int(round(self.q*self.tfmconv))
 489         # b0, b1, b2, b3 = [ord(c) for c in struct.pack(">L", length)]
 490         # assert b0 == 0 or b0 == 255
 491         # shift = 4
 492         # while z >= 8388608:
 493         #     z >>= 1
 494         #     shift -= 1
 495         # assert shift >= 0
 496         # result = ( ( ( ( ( b3 * z ) >> 8 ) + ( b2 * z ) ) >> 8 ) + ( b1 * z ) ) >> shift
 497         # if b0 == 255:
 498         #     result = result - (z << (8-shift))
 499
 500         # however, we can simplify this using a single long integer multiplication,
 501         # but take into account the transformation of z
 502         z = int(round(self.q*self.tfmconv))
 503         assert -16777216 <= length < 16777216 # -(1 << 24) <= length < (1 << 24)
 504         assert z < 134217728 # 1 << 27
 505         shift = 20 # 1 << 20
 506         while z >= 8388608: # 1 << 23
 507             z >>= 1
 508             shift -= 1
 509         # length*z is a long integer, but the result will be a regular integer
 510         return int(length*long(z) >> shift)
 511
 512     def _convert_tfm_to_ds(self, length):
 513         return (16*long(round(length*float(self.q)*self.tfmconv))/16777216) * self.pyxconv * 1000 / self.getsize_pt()
 514
 515     def _convert_tfm_to_pt(self, length):
 516         return (16*long(round(length*float(self.q)*self.tfmconv))/16777216) * self.pyxconv
 517
 518     # routines returning lengths as integers in dvi units
 519
 520     def getwidth_dvi(self, charcode):
 521         return self._convert_tfm_to_dvi(self.tfmfile.width[self.tfmfile.char_info[charcode].width_index])
 522
 523     def getheight_dvi(self, charcode):
 524         return self._convert_tfm_to_dvi(self.tfmfile.height[self.tfmfile.char_info[charcode].height_index])
 525
 526     def getdepth_dvi(self, charcode):
 527         return self._convert_tfm_to_dvi(self.tfmfile.depth[self.tfmfile.char_info[charcode].depth_index])
 528
 529     def getitalic_dvi(self, charcode):
 530         return self._convert_tfm_to_dvi(self.tfmfile.italic[self.tfmfile.char_info[charcode].italic_index])
 531
 532     # routines returning lengths as integers in design size (AFM) units
 533
 534     def getwidth_ds(self, charcode):
 535         return self._convert_tfm_to_ds(self.tfmfile.width[self.tfmfile.char_info[charcode].width_index])
 536
 537     def getheight_ds(self, charcode):
 538         return self._convert_tfm_to_ds(self.tfmfile.height[self.tfmfile.char_info[charcode].height_index])
 539
 540     def getdepth_ds(self, charcode):
 541         return self._convert_tfm_to_ds(self.tfmfile.depth[self.tfmfile.char_info[charcode].depth_index])
 542
 543     def getitalic_ds(self, charcode):
 544         return self._convert_tfm_to_ds(self.tfmfile.italic[self.tfmfile.char_info[charcode].italic_index])
 545
 546     # routines returning lengths as floats in PostScript points
 547
 548     def getwidth_pt(self, charcode):
 549         return self._convert_tfm_to_pt(self.tfmfile.width[self.tfmfile.char_info[charcode].width_index])
 550
 551     def getheight_pt(self, charcode):
 552         return self._convert_tfm_to_pt(self.tfmfile.height[self.tfmfile.char_info[charcode].height_index])
 553
 554     def getdepth_pt(self, charcode):
 555         return self._convert_tfm_to_pt(self.tfmfile.depth[self.tfmfile.char_info[charcode].depth_index])
 556
 557     def getitalic_pt(self, charcode):
 558         return self._convert_tfm_to_pt(self.tfmfile.italic[self.tfmfile.char_info[charcode].italic_index])
 559
 560
 561 class virtualfont(font):
 562     def __init__(self, name, c, q, d, tfmconv, pyxconv, fontmap, debug=0):
 563         fontpath = pykpathsea.find_file(name, pykpathsea.kpse_vf_format)
 564         if fontpath is None or not len(fontpath):
 565             raise RuntimeError
 566         font.__init__(self, name, c, q, d, tfmconv, pyxconv, fontmap, debug)
 567         self.vffile = vffile(fontpath, self.scale, tfmconv, pyxconv, fontmap, debug > 1)
 568
 569     def getfonts(self):
 570         """ return fonts used in virtual font itself """
 571         return self.vffile.getfonts()
 572
 573     def getchar(self, cc):
 574         """ return dvi chunk corresponding to char code cc """
 575         return self.vffile.getchar(cc)
 576
 577
 578 ##############################################################################
 579 # DVI file handling
 580 ##############################################################################
 581
 582 _DVI_CHARMIN     =   0 # typeset a character and move right (range min)
 583 _DVI_CHARMAX     = 127 # typeset a character and move right (range max)
 584 _DVI_SET1234     = 128 # typeset a character and move right
 585 _DVI_SETRULE     = 132 # typeset a rule and move right
 586 _DVI_PUT1234     = 133 # typeset a character
 587 _DVI_PUTRULE     = 137 # typeset a rule
 588 _DVI_NOP         = 138 # no operation
 589 _DVI_BOP         = 139 # beginning of page
 590 _DVI_EOP         = 140 # ending of page
 591 _DVI_PUSH        = 141 # save the current positions (h, v, w, x, y, z)
 592 _DVI_POP         = 142 # restore positions (h, v, w, x, y, z)
 593 _DVI_RIGHT1234   = 143 # move right
 594 _DVI_W0          = 147 # move right by w
 595 _DVI_W1234       = 148 # move right and set w
 596 _DVI_X0          = 152 # move right by x
 597 _DVI_X1234       = 153 # move right and set x
 598 _DVI_DOWN1234    = 157 # move down
 599 _DVI_Y0          = 161 # move down by y
 600 _DVI_Y1234       = 162 # move down and set y
 601 _DVI_Z0          = 166 # move down by z
 602 _DVI_Z1234       = 167 # move down and set z
 603 _DVI_FNTNUMMIN   = 171 # set current font (range min)
 604 _DVI_FNTNUMMAX   = 234 # set current font (range max)
 605 _DVI_FNT1234     = 235 # set current font
 606 _DVI_SPECIAL1234 = 239 # special (dvi extention)
 607 _DVI_FNTDEF1234  = 243 # define the meaning of a font number
 608 _DVI_PRE         = 247 # preamble
 609 _DVI_POST        = 248 # postamble beginning
 610 _DVI_POSTPOST    = 249 # postamble ending
 611
 612 _DVI_VERSION     = 2   # dvi version
 613
 614 # position variable indices
 615 _POS_H           = 0
 616 _POS_V           = 1
 617 _POS_W           = 2
 618 _POS_X           = 3
 619 _POS_Y           = 4
 620 _POS_Z           = 5
 621
 622 # reader states
 623 _READ_PRE       = 1
 624 _READ_NOPAGE    = 2
 625 _READ_PAGE      = 3
 626 _READ_POST      = 4 # XXX not used
 627 _READ_POSTPOST  = 5 # XXX not used
 628 _READ_DONE      = 6
 629
 630
 631 class DVIError(exceptions.Exception): pass
 632
 633 # save and restore colors
 634
 635 class _savecolor(canvas.canvasitem):
 636     def processPS(self, file, writer, context, registry, bbox):
 637         file.write("currentcolor currentcolorspace\n")
 638
 639     def processPDF(self, file, writer, context, registry, bbox):
 640         file.write("q\n")
 641
 642
 643 class _restorecolor(canvas.canvasitem):
 644     def processPS(self, file, writer, context, registry, bbox):
 645         file.write("setcolorspace setcolor\n")
 646
 647     def processPDF(self, file, writer, context, registry, bbox):
 648         file.write("Q\n")
 649
 650 class _savetrafo(canvas.canvasitem):
 651     def processPS(self, file, writer, context, registry, bbox):
 652         file.write("matrix currentmatrix\n")
 653
 654     def processPDF(self, file, writer, context, registry, bbox):
 655         file.write("q\n")
 656
 657
 658 class _restoretrafo(canvas.canvasitem):
 659     def processPS(self, file, writer, context, registry, bbox):
 660         file.write("setmatrix\n")
 661
 662     def processPDF(self, file, writer, context, registry, bbox):
 663         file.write("Q\n")
 664
 665
 666 class dvifile:
 667
 668     def __init__(self, filename, fontmap, debug=0, debugfile=sys.stdout):
 669         """ opens the dvi file and reads the preamble """
 670         self.filename = filename
 671         self.fontmap = fontmap
 672         self.debug = debug
 673         self.debugfile = debugfile
 674         self.debugstack = []
 675
 676         self.fonts = {}
 677         self.activefont = None
 678
 679         # stack of fonts and fontscale currently used (used for VFs)
 680         self.fontstack = []
 681         self.stack = []
 682
 683         # pointer to currently active page
 684         self.actpage = None
 685
 686         # stack for self.file, self.fonts and self.stack, needed for VF inclusion
 687         self.statestack = []
 688
 689         self.file = binfile(self.filename, "rb")
 690
 691         # currently read byte in file (for debugging output)
 692         self.filepos = None
 693
 694         self._read_pre()
 695
 696     # helper routines
 697
 698     def flushtext(self):
 699         """ finish currently active text object """
 700         if self.debug and self.activetext:
 701             self.debugfile.write("[%s]\n" % "".join([chr(char) for char in self.activetext.chars]))
 702         self.activetext = None
 703
 704     def putrule(self, height, width, advancepos=1):
 705         self.flushtext()
 706         x1 =  self.pos[_POS_H] * self.pyxconv
 707         y1 = -self.pos[_POS_V] * self.pyxconv
 708         w = width * self.pyxconv
 709         h = height * self.pyxconv
 710
 711         if height > 0 and width > 0:
 712             if self.debug:
 713                 self.debugfile.write("%d: %srule height %d, width %d (???x??? pixels)\n" %
 714                                      (self.filepos, advancepos and "set" or "put", height, width))
 715             self.actpage.fill(path.rect_pt(x1, y1, w, h))
 716         else:
 717             if self.debug:
 718                 self.debugfile.write("%d: %srule height %d, width %d (invisible)\n" %
 719                                      (self.filepos, advancepos and "set" or "put", height, width))
 720
 721         if advancepos:
 722             if self.debug:
 723                 self.debugfile.write(" h:=%d+%d=%d, hh:=???\n" %
 724                                      (self.pos[_POS_H], width, self.pos[_POS_H]+width))
 725             self.pos[_POS_H] += width
 726
 727     def putchar(self, char, advancepos=1, id1234=0):
 728         dx = advancepos and self.activefont.getwidth_dvi(char) or 0
 729
 730         if self.debug:
 731             self.debugfile.write("%d: %s%s%d h:=%d+%d=%d, hh:=???\n" %
 732                                  (self.filepos,
 733                                   advancepos and "set" or "put",
 734                                   id1234 and "%i " % id1234 or "char",
 735                                   char,
 736                                   self.pos[_POS_H], dx, self.pos[_POS_H]+dx))
 737
 738         if isinstance(self.activefont, virtualfont):
 739             # virtual font handling
 740             afterpos = list(self.pos)
 741             afterpos[_POS_H] += dx
 742             self._push_dvistring(self.activefont.getchar(char), self.activefont.getfonts(), afterpos,
 743                                  self.activefont.getsize_pt())
 744         else:
 745             if self.activetext is None:
 746                 if not self.fontmap.has_key(self.activefont.name):
 747                     raise RuntimeError("missing font information for '%s'; check fontmapping file(s)" % self.activefont.name)
 748                 fontmapinfo = self.fontmap[self.activefont.name]
 749
 750                 encodingname = fontmapinfo.reencodefont
 751                 if encodingname is not None:
 752                     encodingfilename = pykpathsea.find_file(fontmapinfo.encodingfile, pykpathsea.kpse_tex_ps_header_format)
 753                     if not encodingfilename:
 754                         raise RuntimeError("cannot find font encoding file %s" % fontmapinfo.encodingfile)
 755                     fontencoding = type1font.encoding(encodingname, encodingfilename)
 756                 else:
 757                     fontencoding = None
 758
 759                 fontbasefontname = fontmapinfo.basepsname
 760                 if fontmapinfo.fontfile is not None:
 761                     fontfilename = pykpathsea.find_file(fontmapinfo.fontfile, pykpathsea.kpse_type1_format)
 762                     if not fontfilename:
 763                         raise RuntimeError("cannot find type 1 font %s" % fontmapinfo.fontfile)
 764                 else:
 765                     fontfilename = None
 766
 767                 # XXX we currently misuse use self.activefont as metric
 768                 font = type1font.font(fontbasefontname, fontfilename, fontencoding, self.activefont)
 769
 770                 self.activetext = type1font.text_pt(self.pos[_POS_H] * self.pyxconv, -self.pos[_POS_V] * self.pyxconv, font)
 771                 self.actpage.insert(self.activetext)
 772             self.activetext.addchar(char)
 773             self.pos[_POS_H] += dx
 774
 775         if not advancepos:
 776             self.flushtext()
 777
 778     def usefont(self, fontnum, id1234=0):
 779         self.flushtext()
 780         self.activefont = self.fonts[fontnum]
 781         if self.debug:
 782             self.debugfile.write("%d: fnt%s%i current font is %s\n" %
 783                                  (self.filepos,
 784                                   id1234 and "%i " % id1234 or "num",
 785                                   fontnum,
 786                                   self.fonts[fontnum].name))
 787
 788
 789     def definefont(self, cmdnr, num, c, q, d, fontname):
 790         # cmdnr: type of fontdef command (only used for debugging output)
 791         # c:     checksum
 792         # q:     scaling factor (fix_word)
 793         #        Note that q is actually s in large parts of the documentation.
 794         # d:     design size (fix_word)
 795
 796         try:
 797             afont = virtualfont(fontname, c, q/self.tfmconv, d/self.tfmconv, self.tfmconv, self.pyxconv, self.fontmap, self.debug > 1)
 798         except (TypeError, RuntimeError):
 799             afont = font(fontname, c, q/self.tfmconv, d/self.tfmconv, self.tfmconv, self.pyxconv, self.fontmap, self.debug > 1)
 800
 801         self.fonts[num] = afont
 802
 803         if self.debug:
 804             self.debugfile.write("%d: fntdef%d %i: %s\n" % (self.filepos, cmdnr, num, fontname))
 805
 806 #            scale = round((1000.0*self.conv*q)/(self.trueconv*d))
 807 #            m = 1.0*q/d
 808 #            scalestring = scale!=1000 and " scaled %d" % scale or ""
 809 #            print ("Font %i: %s%s---loaded at size %d DVI units" %
 810 #                   (num, fontname, scalestring, q))
 811 #            if scale!=1000:
 812 #                print " (this font is magnified %d%%)" % round(scale/10)
 813
 814     def special(self, s):
 815         x =  self.pos[_POS_H] * self.pyxconv
 816         y = -self.pos[_POS_V] * self.pyxconv
 817         if self.debug:
 818             self.debugfile.write("%d: xxx '%s'\n" % (self.filepos, s))
 819         if not s.startswith("PyX:"):
 820             warnings.warn("ignoring special '%s'" % s)
 821             return
 822
 823         # it is in general not safe to continue using the currently active font because
 824         # the specials may involve some gsave/grestore operations
 825         self.flushtext()
 826
 827         command, args = s[4:].split()[0], s[4:].split()[1:]
 828         if command == "color_begin":
 829             if args[0] == "cmyk":
 830                 c = color.cmyk(float(args[1]), float(args[2]), float(args[3]), float(args[4]))
 831             elif args[0] == "gray":
 832                 c = color.gray(float(args[1]))
 833             elif args[0] == "hsb":
 834                 c = color.hsb(float(args[1]), float(args[2]), float(args[3]))
 835             elif args[0] == "rgb":
 836                 c = color.rgb(float(args[1]), float(args[2]), float(args[3]))
 837             elif args[0] == "RGB":
 838                 c = color.rgb(int(args[1])/255.0, int(args[2])/255.0, int(args[3])/255.0)
 839             elif args[0] == "texnamed":
 840                 try:
 841                     c = getattr(color.cmyk, args[1])
 842                 except AttributeError:
 843                     raise RuntimeError("unknown TeX color '%s', aborting" % args[1])
 844             else:
 845                 raise RuntimeError("color model '%s' cannot be handled by PyX, aborting" % args[0])
 846             self.actpage.insert(_savecolor())
 847             self.actpage.insert(c)
 848         elif command == "color_end":
 849             self.actpage.insert(_restorecolor())
 850         elif command == "rotate_begin":
 851             self.actpage.insert(_savetrafo())
 852             self.actpage.insert(trafo.rotate_pt(float(args[0]), x, y))
 853         elif command == "rotate_end":
 854             self.actpage.insert(_restoretrafo())
 855         elif command == "scale_begin":
 856             self.actpage.insert(_savetrafo())
 857             self.actpage.insert(trafo.scale_pt(float(args[0]), float(args[1]), x, y))
 858         elif command == "scale_end":
 859             self.actpage.insert(_restoretrafo())
 860         elif command == "epsinclude":
 861             # parse arguments
 862             argdict = {}
 863             for arg in args:
 864                 name, value = arg.split("=")
 865                 argdict[name] = value
 866
 867             # construct kwargs for epsfile constructor
 868             epskwargs = {}
 869             epskwargs["filename"] = argdict["file"]
 870             epskwargs["bbox"] = bbox.bbox_pt(float(argdict["llx"]), float(argdict["lly"]),
 871                                            float(argdict["urx"]), float(argdict["ury"]))
 872             if argdict.has_key("width"):
 873                 epskwargs["width"] = float(argdict["width"]) * unit.t_pt
 874             if argdict.has_key("height"):
 875                 epskwargs["height"] = float(argdict["height"]) * unit.t_pt
 876             if argdict.has_key("clip"):
 877                epskwargs["clip"] = int(argdict["clip"])
 878             self.actpage.insert(epsfile.epsfile(x * unit.t_pt, y * unit.t_pt, **epskwargs))
 879         elif command == "marker":
 880             if len(args) != 1:
 881                 raise RuntimeError("marker contains spaces")
 882             for c in args[0]:
 883                 if c not in string.digits + string.letters + "@":
 884                     raise RuntimeError("marker contains invalid characters")
 885             if self.actpage.markers.has_key(args[0]):
 886                 raise RuntimeError("marker name occurred several times")
 887             self.actpage.markers[args[0]] = x * unit.t_pt, y * unit.t_pt
 888         else:
 889             raise RuntimeError("unknown PyX special '%s', aborting" % command)
 890
 891     # routines for pushing and popping different dvi chunks on the reader
 892
 893     def _push_dvistring(self, dvi, fonts, afterpos, fontsize):
 894         """ push dvi string with defined fonts on top of reader
 895         stack. Every positions gets scaled relatively by the factor
 896         scale. After the interpreting of the dvi chunk has been finished,
 897         continue with self.pos=afterpos. The designsize of the virtual
 898         font is passed as a fix_word
 899
 900         """
 901
 902         #if self.debug:
 903         #    self.debugfile.write("executing new dvi chunk\n")
 904         self.debugstack.append(self.debug)
 905         self.debug = 0
 906
 907         self.statestack.append((self.file, self.fonts, self.activefont, afterpos, self.stack, self.pyxconv, self.tfmconv))
 908
 909         # units in vf files are relative to the size of the font and given as fix_words
 910         # which can be converted to floats by diving by 2**20
 911         oldpyxconv = self.pyxconv
 912         self.pyxconv = fontsize/2**20
 913         rescale = self.pyxconv/oldpyxconv
 914
 915         self.file = stringbinfile(dvi)
 916         self.fonts = fonts
 917         self.stack = []
 918         self.filepos = 0
 919
 920         # rescale self.pos in order to be consistent with the new scaling
 921         self.pos = map(lambda x, rescale=rescale:1.0*x/rescale, self.pos)
 922
 923         # since tfmconv converts from tfm units to dvi units, rescale it as well
 924         self.tfmconv /= rescale
 925
 926         self.usefont(0)
 927
 928     def _pop_dvistring(self):
 929         self.flushtext()
 930         #if self.debug:
 931         #    self.debugfile.write("finished executing dvi chunk\n")
 932         self.debug = self.debugstack.pop()
 933
 934         self.file.close()
 935         self.file, self.fonts, self.activefont, self.pos, self.stack, self.pyxconv, self.tfmconv = self.statestack.pop()
 936
 937     # routines corresponding to the different reader states of the dvi maschine
 938
 939     def _read_pre(self):
 940         afile = self.file
 941         while 1:
 942             self.filepos = afile.tell()
 943             cmd = afile.readuchar()
 944             if cmd == _DVI_NOP:
 945                 pass
 946             elif cmd == _DVI_PRE:
 947                 if afile.readuchar() != _DVI_VERSION: raise DVIError
 948                 num = afile.readuint32()
 949                 den = afile.readuint32()
 950                 self.mag = afile.readuint32()
 951
 952                 # For the interpretation of the lengths in dvi and tfm files,
 953                 # three conversion factors are relevant:
 954                 # - self.tfmconv: tfm units -> dvi units
 955                 # - self.pyxconv: dvi units -> (PostScript) points
 956                 # - self.conv:    dvi units -> pixels
 957                 self.tfmconv = (25400000.0/num)*(den/473628672.0)/16.0
 958
 959                 # calculate conv as described in the DVIType docu using
 960                 # a given resolution in dpi
 961                 self.resolution = 300.0
 962                 self.conv = (num/254000.0)*(self.resolution/den)
 963
 964                 # self.pyxconv is the conversion factor from the dvi units
 965                 # to (PostScript) points. It consists of
 966                 # - self.mag/1000.0:   magstep scaling
 967                 # - self.conv:         conversion from dvi units to pixels
 968                 # - 1/self.resolution: conversion from pixels to inch
 969                 # - 72               : conversion from inch to points
 970                 self.pyxconv = self.mag/1000.0*self.conv/self.resolution*72
 971
 972                 comment = afile.read(afile.readuchar())
 973                 return
 974             else:
 975                 raise DVIError
 976
 977     def readpage(self, pageid=None):
 978         """ reads a page from the dvi file
 979
 980         This routine reads a page from the dvi file which is
 981         returned as a canvas. When there is no page left in the
 982         dvifile, None is returned and the file is closed properly."""
 983
 984         while 1:
 985             self.filepos = self.file.tell()
 986             cmd = self.file.readuchar()
 987             if cmd == _DVI_NOP:
 988                 pass
 989             elif cmd == _DVI_BOP:
 990                 ispageid = [self.file.readuint32() for i in range(10)]
 991                 if pageid is not None and ispageid != pageid:
 992                     raise DVIError("invalid pageid")
 993                 if self.debug:
 994                     self.debugfile.write("%d: beginning of page %i\n" % (self.filepos, ispageid[0]))
 995                 self.file.readuint32()
 996                 break
 997             elif cmd == _DVI_POST:
 998                 self.file.close()
 999                 return None # nothing left
1000             else:
1001                 raise DVIError
1002
1003         self.actpage = canvas.canvas()
1004         self.actpage.markers = {}
1005         self.pos = [0, 0, 0, 0, 0, 0]
1006
1007         # currently active output: text instance currently used
1008         self.activetext = None
1009
1010         while 1:
1011             afile = self.file
1012             self.filepos = afile.tell()
1013             try:
1014                 cmd = afile.readuchar()
1015             except struct.error:
1016                 # we most probably (if the dvi file is not corrupt) hit the end of a dvi chunk,
1017                 # so we have to continue with the rest of the dvi file
1018                 self._pop_dvistring()
1019                 continue
1020             if cmd == _DVI_NOP:
1021                 pass
1022             if cmd >= _DVI_CHARMIN and cmd <= _DVI_CHARMAX:
1023                 self.putchar(cmd)
1024             elif cmd >= _DVI_SET1234 and cmd < _DVI_SET1234 + 4:
1025                 self.putchar(afile.readint(cmd - _DVI_SET1234 + 1), id1234=cmd-_DVI_SET1234+1)
1026             elif cmd == _DVI_SETRULE:
1027                 self.putrule(afile.readint32(), afile.readint32())
1028             elif cmd >= _DVI_PUT1234 and cmd < _DVI_PUT1234 + 4:
1029                 self.putchar(afile.readint(cmd - _DVI_PUT1234 + 1), advancepos=0, id1234=cmd-_DVI_SET1234+1)
1030             elif cmd == _DVI_PUTRULE:
1031                 self.putrule(afile.readint32(), afile.readint32(), 0)
1032             elif cmd == _DVI_EOP:
1033                 self.flushtext()
1034                 if self.debug:
1035                     self.debugfile.write("%d: eop\n \n" % self.filepos)
1036                 return self.actpage
1037             elif cmd == _DVI_PUSH:
1038                 self.stack.append(list(self.pos))
1039                 if self.debug:
1040                     self.debugfile.write("%s: push\n"
1041                                          "level %d:(h=%d,v=%d,w=%d,x=%d,y=%d,z=%d,hh=???,vv=???)\n" %
1042                                          ((self.filepos, len(self.stack)-1) + tuple(self.pos)))
1043             elif cmd == _DVI_POP:
1044                 self.flushtext()
1045                 self.pos = self.stack.pop()
1046                 if self.debug:
1047                     self.debugfile.write("%s: pop\n"
1048                                          "level %d:(h=%d,v=%d,w=%d,x=%d,y=%d,z=%d,hh=???,vv=???)\n" %
1049                                          ((self.filepos, len(self.stack)) + tuple(self.pos)))
1050             elif cmd >= _DVI_RIGHT1234 and cmd < _DVI_RIGHT1234 + 4:
1051                 self.flushtext()
1052                 dh = afile.readint(cmd - _DVI_RIGHT1234 + 1, 1)
1053                 if self.debug:
1054                     self.debugfile.write("%d: right%d %d h:=%d%+d=%d, hh:=???\n" %
1055                                          (self.filepos,
1056                                           cmd - _DVI_RIGHT1234 + 1,
1057                                           dh,
1058                                           self.pos[_POS_H],
1059                                           dh,
1060                                           self.pos[_POS_H]+dh))
1061                 self.pos[_POS_H] += dh
1062             elif cmd == _DVI_W0:
1063                 self.flushtext()
1064                 if self.debug:
1065                     self.debugfile.write("%d: w0 %d h:=%d%+d=%d, hh:=???\n" %
1066                                          (self.filepos,
1067                                           self.pos[_POS_W],
1068                                           self.pos[_POS_H],
1069                                           self.pos[_POS_W],
1070                                           self.pos[_POS_H]+self.pos[_POS_W]))
1071                 self.pos[_POS_H] += self.pos[_POS_W]
1072             elif cmd >= _DVI_W1234 and cmd < _DVI_W1234 + 4:
1073                 self.flushtext()
1074                 self.pos[_POS_W] = afile.readint(cmd - _DVI_W1234 + 1, 1)
1075                 if self.debug:
1076                     self.debugfile.write("%d: w%d %d h:=%d%+d=%d, hh:=???\n" %
1077                                          (self.filepos,
1078                                           cmd - _DVI_W1234 + 1,
1079                                           self.pos[_POS_W],
1080                                           self.pos[_POS_H],
1081                                           self.pos[_POS_W],
1082                                           self.pos[_POS_H]+self.pos[_POS_W]))
1083                 self.pos[_POS_H] += self.pos[_POS_W]
1084             elif cmd == _DVI_X0:
1085                 self.flushtext()
1086                 if self.debug:
1087                     self.debugfile.write("%d: x0 %d h:=%d%+d=%d, hh:=???\n" %
1088                                          (self.filepos,
1089                                           self.pos[_POS_X],
1090                                           self.pos[_POS_H],
1091                                           self.pos[_POS_X],
1092                                           self.pos[_POS_H]+self.pos[_POS_X]))
1093                 self.pos[_POS_H] += self.pos[_POS_X]
1094             elif cmd >= _DVI_X1234 and cmd < _DVI_X1234 + 4:
1095                 self.flushtext()
1096                 self.pos[_POS_X] = afile.readint(cmd - _DVI_X1234 + 1, 1)
1097                 if self.debug:
1098                     self.debugfile.write("%d: x%d %d h:=%d%+d=%d, hh:=???\n" %
1099                                          (self.filepos,
1100                                           cmd - _DVI_X1234 + 1,
1101                                           self.pos[_POS_X],
1102                                           self.pos[_POS_H],
1103                                           self.pos[_POS_X],
1104                                           self.pos[_POS_H]+self.pos[_POS_X]))
1105                 self.pos[_POS_H] += self.pos[_POS_X]
1106             elif cmd >= _DVI_DOWN1234 and cmd < _DVI_DOWN1234 + 4:
1107                 self.flushtext()
1108                 dv = afile.readint(cmd - _DVI_DOWN1234 + 1, 1)
1109                 if self.debug:
1110                     self.debugfile.write("%d: down%d %d v:=%d%+d=%d, vv:=???\n" %
1111                                          (self.filepos,
1112                                           cmd - _DVI_DOWN1234 + 1,
1113                                           dv,
1114                                           self.pos[_POS_V],
1115                                           dv,
1116                                           self.pos[_POS_V]+dv))
1117                 self.pos[_POS_V] += dv
1118             elif cmd == _DVI_Y0:
1119                 self.flushtext()
1120                 if self.debug:
1121                     self.debugfile.write("%d: y0 %d v:=%d%+d=%d, vv:=???\n" %
1122                                          (self.filepos,
1123                                           self.pos[_POS_Y],
1124                                           self.pos[_POS_V],
1125                                           self.pos[_POS_Y],
1126                                           self.pos[_POS_V]+self.pos[_POS_Y]))
1127                 self.pos[_POS_V] += self.pos[_POS_Y]
1128             elif cmd >= _DVI_Y1234 and cmd < _DVI_Y1234 + 4:
1129                 self.flushtext()
1130                 self.pos[_POS_Y] = afile.readint(cmd - _DVI_Y1234 + 1, 1)
1131                 if self.debug:
1132                     self.debugfile.write("%d: y%d %d v:=%d%+d=%d, vv:=???\n" %
1133                                          (self.filepos,
1134                                           cmd - _DVI_Y1234 + 1,
1135                                           self.pos[_POS_Y],
1136                                           self.pos[_POS_V],
1137                                           self.pos[_POS_Y],
1138                                           self.pos[_POS_V]+self.pos[_POS_Y]))
1139                 self.pos[_POS_V] += self.pos[_POS_Y]
1140             elif cmd == _DVI_Z0:
1141                 self.flushtext()
1142                 if self.debug:
1143                     self.debugfile.write("%d: z0 %d v:=%d%+d=%d, vv:=???\n" %
1144                                          (self.filepos,
1145                                           self.pos[_POS_Z],
1146                                           self.pos[_POS_V],
1147                                           self.pos[_POS_Z],
1148                                           self.pos[_POS_V]+self.pos[_POS_Z]))
1149                 self.pos[_POS_V] += self.pos[_POS_Z]
1150             elif cmd >= _DVI_Z1234 and cmd < _DVI_Z1234 + 4:
1151                 self.flushtext()
1152                 self.pos[_POS_Z] = afile.readint(cmd - _DVI_Z1234 + 1, 1)
1153                 if self.debug:
1154                     self.debugfile.write("%d: z%d %d v:=%d%+d=%d, vv:=???\n" %
1155                                          (self.filepos,
1156                                           cmd - _DVI_Z1234 + 1,
1157                                           self.pos[_POS_Z],
1158                                           self.pos[_POS_V],
1159                                           self.pos[_POS_Z],
1160                                           self.pos[_POS_V]+self.pos[_POS_Z]))
1161                 self.pos[_POS_V] += self.pos[_POS_Z]
1162             elif cmd >= _DVI_FNTNUMMIN and cmd <= _DVI_FNTNUMMAX:
1163                 self.usefont(cmd - _DVI_FNTNUMMIN, 0)
1164             elif cmd >= _DVI_FNT1234 and cmd < _DVI_FNT1234 + 4:
1165                 # note that according to the DVI docs, for four byte font numbers,
1166                 # the font number is signed. Don't ask why!
1167                 fntnum = afile.readint(cmd - _DVI_FNT1234 + 1, cmd == _DVI_FNT1234 + 3)
1168                 self.usefont(fntnum, id1234=cmd-_DVI_FNT1234+1)
1169             elif cmd >= _DVI_SPECIAL1234 and cmd < _DVI_SPECIAL1234 + 4:
1170                 self.special(afile.read(afile.readint(cmd - _DVI_SPECIAL1234 + 1)))
1171             elif cmd >= _DVI_FNTDEF1234 and cmd < _DVI_FNTDEF1234 + 4:
1172                 if cmd == _DVI_FNTDEF1234:
1173                     num = afile.readuchar()
1174                 elif cmd == _DVI_FNTDEF1234+1:
1175                     num = afile.readuint16()
1176                 elif cmd == _DVI_FNTDEF1234+2:
1177                     num = afile.readuint24()
1178                 elif cmd == _DVI_FNTDEF1234+3:
1179                     # Cool, here we have according to docu a signed int. Why?
1180                     num = afile.readint32()
1181                 self.definefont(cmd-_DVI_FNTDEF1234+1,
1182                                 num,
1183                                 afile.readint32(),
1184                                 afile.readint32(),
1185                                 afile.readint32(),
1186                                 afile.read(afile.readuchar()+afile.readuchar()))
1187             else:
1188                 raise DVIError
1189
1190
1191 ##############################################################################
1192 # VF file handling
1193 ##############################################################################
1194
1195 _VF_LONG_CHAR  = 242              # character packet (long version)
1196 _VF_FNTDEF1234 = _DVI_FNTDEF1234  # font definition
1197 _VF_PRE        = _DVI_PRE         # preamble
1198 _VF_POST       = _DVI_POST        # postamble
1199
1200 _VF_ID         = 202              # VF id byte
1201
1202 class VFError(exceptions.Exception): pass
1203
1204 class vffile:
1205     def __init__(self, filename, scale, tfmconv, pyxconv, fontmap, debug=0):
1206         self.filename = filename
1207         self.scale = scale
1208         self.tfmconv = tfmconv
1209         self.pyxconv = pyxconv
1210         self.fontmap = fontmap
1211         self.debug = debug
1212         self.fonts = {}            # used fonts
1213         self.widths = {}           # widths of defined chars
1214         self.chardefs = {}         # dvi chunks for defined chars
1215
1216         afile = binfile(self.filename, "rb")
1217
1218         cmd = afile.readuchar()
1219         if cmd == _VF_PRE:
1220             if afile.readuchar() != _VF_ID: raise VFError
1221             comment = afile.read(afile.readuchar())
1222             self.cs = afile.readuint32()
1223             self.ds = afile.readuint32()
1224         else:
1225             raise VFError
1226
1227         while 1:
1228             cmd = afile.readuchar()
1229             if cmd >= _VF_FNTDEF1234 and cmd < _VF_FNTDEF1234 + 4:
1230                 # font definition
1231                 if cmd == _VF_FNTDEF1234:
1232                     num = afile.readuchar()
1233                 elif cmd == _VF_FNTDEF1234+1:
1234                     num = afile.readuint16()
1235                 elif cmd == _VF_FNTDEF1234+2:
1236                     num = afile.readuint24()
1237                 elif cmd == _VF_FNTDEF1234+3:
1238                     num = afile.readint32()
1239                 c = afile.readint32()
1240                 s = afile.readint32()     # relative scaling used for font (fix_word)
1241                 d = afile.readint32()     # design size of font
1242                 fontname = afile.read(afile.readuchar()+afile.readuchar())
1243
1244                 # rescaled size of font: s is relative to the scaling
1245                 # of the virtual font itself.  Note that realscale has
1246                 # to be a fix_word (like s)
1247                 # XXX: check rounding
1248                 reals = int(round(self.scale * (16*self.ds/16777216L) * s))
1249
1250                 # print ("defining font %s -- VF scale: %g, VF design size: %d, relative font size: %d => real size: %d" %
1251                 #        (fontname, self.scale, self.ds, s, reals)
1252                 #        )
1253
1254                 # XXX allow for virtual fonts here too
1255                 self.fonts[num] =  font(fontname, c, reals, d, self.tfmconv, self.pyxconv, self.fontmap, self.debug > 1)
1256             elif cmd == _VF_LONG_CHAR:
1257                 # character packet (long form)
1258                 pl = afile.readuint32()   # packet length
1259                 cc = afile.readuint32()   # char code (assumed unsigned, but anyhow only 0 <= cc < 255 is actually used)
1260                 tfm = afile.readuint24()  # character width
1261                 dvi = afile.read(pl)      # dvi code of character
1262                 self.widths[cc] = tfm
1263                 self.chardefs[cc] = dvi
1264             elif cmd < _VF_LONG_CHAR:
1265                 # character packet (short form)
1266                 cc = afile.readuchar()    # char code
1267                 tfm = afile.readuint24()  # character width
1268                 dvi = afile.read(cmd)
1269                 self.widths[cc] = tfm
1270                 self.chardefs[cc] = dvi
1271             elif cmd == _VF_POST:
1272                 break
1273             else:
1274                 raise VFError
1275
1276         afile.close()
1277
1278     def getfonts(self):
1279         return self.fonts
1280
1281     def getchar(self, cc):
1282         return self.chardefs[cc]
1283
1284