2 # -*- coding: ISO-8859-1 -*-
5 # Copyright (C) 2002-2004 Jörg Lehmann <joergl@users.sourceforge.net>
6 # Copyright (C) 2003-2004 Michael Schindler <m-schindler@users.sourceforge.net>
7 # Copyright (C) 2002-2004 André Wobst <wobsta@users.sourceforge.net>
9 # This file is part of PyX (http://pyx.sourceforge.net/).
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.
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.
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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
25 import copy
, cStringIO
, exceptions
, re
, struct
, string
, sys
26 import unit
, epsfile
, bbox
, base
, canvas
, color
, trafo
, path
, prolog
, pykpathsea
29 def __init__(self
, word
):
35 self
.precomma
= abs(word
) >> 20
36 self
.postcomma
= abs(word
) & 0xFFFFF
39 return self
.sign
* (self
.precomma
+ 1.0*self
.postcomma
/0xFFFFF)
41 def __mul__(self
, other
):
45 result
.sign
= self
.sign
*other
.sign
46 c
= self
.postcomma
*other
.precomma
+ self
.precomma
*other
.postcomma
47 result
.precomma
= self
.precomma
*other
.precomma
+ (c
>> 20)
48 result
.postcomma
= c
& 0xFFFFF + ((self
.postcomma
*other
.postcomma
) >> 40)
54 def __init__(self
, filename
, mode
="r"):
55 self
.file = open(filename
, mode
)
61 return self
.file.tell()
64 return self
.file.eof()
66 def read(self
, bytes
):
67 return self
.file.read(bytes
)
69 def readint(self
, bytes
=4, signed
=0):
73 value
= ord(self
.file.read(1))
74 if first
and signed
and value
> 127:
77 result
= 256 * result
+ value
82 return struct
.unpack(">l", self
.file.read(4))[0]
85 return struct
.unpack(">L", self
.file.read(4))[0]
89 return struct
.unpack(">l", "\0"+self
.file.read(3))[0]
93 return struct
.unpack(">L", "\0"+self
.file.read(3))[0]
96 return struct
.unpack(">h", self
.file.read(2))[0]
99 return struct
.unpack(">H", self
.file.read(2))[0]
102 return struct
.unpack("b", self
.file.read(1))[0]
105 return struct
.unpack("B", self
.file.read(1))[0]
107 def readstring(self
, bytes
):
109 assert l
<= bytes
-1, "inconsistency in file: string too long"
110 return self
.file.read(bytes
-1)[:l
]
112 class stringbinfile(binfile
):
114 def __init__(self
, s
):
115 self
.file = cStringIO
.StringIO(s
)
119 # """ ascii file containing tokens separated by spaces.
121 # Comments beginning with % are ignored. Strings containing spaces
122 # are not handled correctly
125 # def __init__(self, filename):
126 # self.file = open(filename, "r")
129 # def gettoken(self):
130 # """ return next token or None if EOF """
131 # while not self.line:
132 # line = self.file.readline()
135 # self.line = line.split("%")[0].split()
136 # token = self.line[0]
137 # self.line = self.line[1:]
144 ##############################################################################
146 ##############################################################################
148 class TFMError(exceptions
.Exception): pass
151 class char_info_word
:
152 def __init__(self
, word
):
153 self
.width_index
= int((word
& 0xFF000000L
) >> 24) #make sign-safe
154 self
.height_index
= (word
& 0x00F00000) >> 20
155 self
.depth_index
= (word
& 0x000F0000) >> 16
156 self
.italic_index
= (word
& 0x0000FC00) >> 10
157 self
.tag
= (word
& 0x00000300) >> 8
158 self
.remainder
= (word
& 0x000000FF)
162 def __init__(self
, name
, debug
=0):
163 self
.file = binfile(name
, "rb")
170 self
.lf
= self
.file.readint16()
171 self
.lh
= self
.file.readint16()
172 self
.bc
= self
.file.readint16()
173 self
.ec
= self
.file.readint16()
174 self
.nw
= self
.file.readint16()
175 self
.nh
= self
.file.readint16()
176 self
.nd
= self
.file.readint16()
177 self
.ni
= self
.file.readint16()
178 self
.nl
= self
.file.readint16()
179 self
.nk
= self
.file.readint16()
180 self
.ne
= self
.file.readint16()
181 self
.np
= self
.file.readint16()
183 if not (self
.bc
-1 <= self
.ec
<= 255 and
185 self
.lf
== 6+self
.lh
+(self
.ec
-self
.bc
+1)+self
.nw
+self
.nh
+self
.nd
186 +self
.ni
+self
.nl
+self
.nk
+self
.ne
+self
.np
):
187 raise TFMError
, "error in TFM pre-header"
190 print "lh=%d" % self
.lh
196 self
.checksum
= self
.file.readint32()
197 self
.designsizeraw
= self
.file.readint32()
198 assert self
.designsizeraw
> 0, "invald design size"
199 self
.designsize
= fix_word(self
.designsizeraw
)
201 assert self
.lh
> 11, "inconsistency in TFM file: incomplete field"
202 self
.charcoding
= self
.file.readstring(40)
204 self
.charcoding
= None
207 assert self
.lh
> 16, "inconsistency in TFM file: incomplete field"
208 self
.fontfamily
= self
.file.readstring(20)
210 self
.fontfamily
= None
213 print "(FAMILY %s)" % self
.fontfamily
214 print "(CODINGSCHEME %s)" % self
.charcoding
215 print "(DESINGSIZE R %f)" % self
.designsize
218 self
.sevenbitsave
= self
.file.readuchar()
219 # ignore the following two bytes
220 self
.file.readint16()
221 facechar
= self
.file.readuchar()
222 # decode ugly face specification into the Knuth suggested string
234 self
.face
= "L" + self
.face
237 self
.face
= "B" + self
.face
240 self
.face
= "M" + self
.face
243 self
.face
= self
.face
[0] + "I" + self
.face
[1]
245 self
.face
= self
.face
[0] + "R" + self
.face
[1]
250 self
.sevenbitsave
= self
.face
= None
253 # just ignore the rest
254 print self
.file.read((self
.lh
-18)*4)
260 self
.char_info
= [None]*(self
.ec
+1)
261 for charcode
in range(self
.bc
, self
.ec
+1):
262 self
.char_info
[charcode
] = char_info_word(self
.file.readint32())
263 if self
.char_info
[charcode
].width_index
== 0:
264 # disable character if width_index is zero
265 self
.char_info
[charcode
] = None
271 self
.width
= [None for width_index
in range(self
.nw
)]
272 for width_index
in range(self
.nw
):
273 # self.width[width_index] = fix_word(self.file.readint32())
274 self
.width
[width_index
] = self
.file.readint32()
280 self
.height
= [None for height_index
in range(self
.nh
)]
281 for height_index
in range(self
.nh
):
282 # self.height[height_index] = fix_word(self.file.readint32())
283 self
.height
[height_index
] = self
.file.readint32()
289 self
.depth
= [None for depth_index
in range(self
.nd
)]
290 for depth_index
in range(self
.nd
):
291 # self.depth[depth_index] = fix_word(self.file.readint32())
292 self
.depth
[depth_index
] = self
.file.readint32()
298 self
.italic
= [None for italic_index
in range(self
.ni
)]
299 for italic_index
in range(self
.ni
):
300 # self.italic[italic_index] = fix_word(self.file.readint32())
301 self
.italic
[italic_index
] = self
.file.readint32()
307 # XXX decode to lig_kern_command
309 self
.lig_kern
= [None for lig_kern_index
in range(self
.nl
)]
310 for lig_kern_index
in range(self
.nl
):
311 self
.lig_kern
[lig_kern_index
] = self
.file.readint32()
317 self
.kern
= [None for kern_index
in range(self
.nk
)]
318 for kern_index
in range(self
.nk
):
319 # self.kern[kern_index] = fix_word(self.file.readint32())
320 self
.kern
[kern_index
] = self
.file.readint32()
326 # XXX decode to extensible_recipe
328 self
.exten
= [None for exten_index
in range(self
.ne
)]
329 for exten_index
in range(self
.ne
):
330 self
.exten
[exten_index
] = self
.file.readint32()
338 self
.param
= [None for param_index
in range(self
.np
)]
339 for param_index
in range(self
.np
):
340 self
.param
[param_index
] = self
.file.readint32()
345 # class FontEncoding:
347 # def __init__(self, filename):
348 # """ font encoding contained in filename """
349 # encpath = pykpathsea.find_file(filename, pykpathsea.kpse_tex_ps_header_format)
350 # encfile = tokenfile(encpath)
353 # self.encname = encfile.gettoken()
354 # token = encfile.gettoken()
356 # raise RuntimeError("cannot parse encoding file '%s', expecting '[' got '%s'" % (filename, token))
357 # self.encvector = []
358 # for i in range(256):
359 # token = encfile.gettoken()
360 # if token is None or token=="]":
361 # raise RuntimeError("not enough charcodes in encoding file '%s'" % filename)
362 # self.encvector.append(token)
363 # if encfile.gettoken() != "]":
364 # raise RuntimeError("too many charcodes in encoding file '%s'" % filename)
365 # token = encfile.gettoken()
367 # raise RuntimeError("cannot parse encoding file '%s', expecting 'def' got '%s'" % (filename, token))
368 # token = encfile.gettoken()
370 # raise RuntimeError("encoding file '%s' too long" % filename)
373 # def encode(self, charcode):
374 # return self.encvector[charcode]
376 ##############################################################################
378 ##############################################################################
380 _ReEncodeFont
= prolog
.definition("ReEncodeFont", """{
383 /newencoding exch def
384 /newfontname exch def
385 /basefontname exch def
386 /basefontdict basefontname findfont def
387 /newfontdict basefontdict maxlength dict def
389 exch dup dup /FID ne exch /Encoding ne and
390 { exch newfontdict 3 1 roll put }
394 newfontdict /FontName newfontname put
395 newfontdict /Encoding newencoding put
396 newfontname newfontdict definefont pop
401 # PostScript font selection and output primitives
404 class _begintextobject(base
.PSOp
):
405 def outputPS(self
, file):
408 def outputPDF(self
, file):
412 class _endtextobject(base
.PSOp
):
413 def outputPS(self
, file):
416 def outputPDF(self
, file):
420 class _selectfont(base
.PSOp
):
421 def __init__(self
, name
, size
):
425 def outputPS(self
, file):
426 file.write("/%s %f selectfont\n" % (self
.name
, self
.size
))
428 def outputPDF(self
, file):
429 file.write("/%s %f Tf\n" % (self
.name
, self
.size
))
432 class selectfont(_selectfont
):
433 def __init__(self
, font
):
434 _selectfont
.__init
__(self
, font
.getpsname(), font
.getsize())
438 result
= [prolog
.fontdefinition(self
.font
,
439 self
.font
.getbasepsname(),
440 self
.font
.getfontfile(),
441 self
.font
.getencodingfile(),
442 self
.font
.usedchars
)]
443 if self
.font
.getencoding():
444 result
.append(_ReEncodeFont
)
445 result
.append(prolog
.fontencoding(self
.font
.getencoding(), self
.font
.getencodingfile()))
446 result
.append(prolog
.fontreencoding(self
.font
.getpsname(), self
.font
.getbasepsname(), self
.font
.getencoding()))
450 class _show(base
.PSCmd
):
452 def __init__(self
, x
, y
):
460 def addchar(self
, width
, height
, depth
, char
):
462 if height
> self
.height
:
464 if depth
> self
.depth
:
466 self
.chars
.append(char
)
469 return bbox
.bbox_pt(self
.x
, self
.y
-self
.depth
, self
.x
+self
.width
, self
.y
+self
.height
)
471 def outputPS(self
, file):
473 for char
in self
.chars
:
474 if char
> 32 and char
< 127 and chr(char
) not in "()[]<>\\":
475 ascii
= "%s" % chr(char
)
477 ascii
= "\\%03o" % char
479 file.write("%g %g moveto (%s) show\n" % (self
.x
, self
.y
, outstring
))
481 def outputPDF(self
, file):
483 for char
in self
.chars
:
484 if char
> 32 and char
< 127 and chr(char
) not in "()[]<>\\":
485 ascii
= "%s" % chr(char
)
487 ascii
= "\\%03o" % char
489 # file.write("%f %f Td (%s) Tj\n" % (self.x, self.y, outstring))
490 file.write("1 0 0 1 %f %f Tm (%s) Tj\n" % (self
.x
, self
.y
, outstring
))
495 tokenpattern
= re
.compile(r
'"(.*?)("\s+|"$|$)|(.*?)(\s+|$)')
497 def __init__(self
, s
):
498 """ construct font mapping from line s of font mapping file """
499 self
.texname
= self
.basepsname
= self
.fontfile
= None
502 self
.encodingfile
= None
504 # supported postscript fragments occuring in psfonts.map
505 self
.reencodefont
= self
.extendfont
= self
.slantfont
= None
509 match
= self
.tokenpattern
.match(s
)
511 if match
.groups()[0]:
512 tokens
.append('"%s"' % match
.groups()[0])
514 tokens
.append(match
.groups()[2])
517 raise RuntimeError("wrong syntax")
520 if token
.startswith("<"):
521 if token
.startswith("<<"):
522 # XXX: support non-partial download here
523 self
.fontfile
= token
[2:]
524 elif token
.startswith("<["):
525 self
.encodingfile
= token
[2:]
526 elif token
.endswith(".pfa") or token
.endswith(".pfb"):
527 self
.fontfile
= token
[1:]
528 elif token
.endswith(".enc"):
529 self
.encodingfile
= token
[1:]
531 raise RuntimeError("wrong syntax")
532 elif token
.startswith('"'):
533 pscode
= token
[1:-1].split()
534 # parse standard postscript code fragments
537 arg
, cmd
= pscode
[:2]
539 raise RuntimeError("Unsupported Postscript fragment '%s'" % pscode
)
541 if cmd
== "ReEncodeFont":
542 self
.reencodefont
= arg
543 elif cmd
== "ExtendFont":
544 self
.extendfont
= arg
545 elif cmd
== "SlantFont":
548 raise RuntimeError("Unsupported Postscript fragment '%s %s'" % (arg
, cmd
))
550 if self
.texname
is None:
553 self
.basepsname
= token
554 if self
.basepsname
is None:
555 self
.basepsname
= self
.texname
558 return ("'%s' is '%s' read from '%s' encoded as '%s'" %
559 (self
.texname
, self
.basepsname
, self
.fontfile
, repr(self
.encodingfile
)))
563 def readfontmap(filenames
):
564 """ read font map from filename (without path) """
566 for filename
in filenames
:
567 mappath
= pykpathsea
.find_file(filename
, pykpathsea
.kpse_fontmap_format
)
568 # try also the oft-used registration as dvips config file
570 mappath
= pykpathsea
.find_file(filename
, pykpathsea
.kpse_dvips_config_format
)
572 raise RuntimeError("cannot find font mapping file '%s'" % filename
)
573 mapfile
= open(mappath
, "r")
575 for line
in mapfile
.readlines():
578 if not (line
=="" or line
[0] in (" ", "%", "*", ";" , "#")):
580 fm
= fontmapping(line
)
581 except RuntimeError, e
:
582 sys
.stderr
.write("*** PyX Warning: Ignoring line %i in mapping file '%s': %s\n" % (lineno
, filename
, e
))
584 fontmap
[fm
.texname
] = fm
590 def __init__(self
, name
, c
, q
, d
, debug
=0):
592 self
.q
= q
# desired size of font (fix_word) in tex points
593 self
.d
= d
# design size of font (fix_word) in tex points
594 tfmpath
= pykpathsea
.find_file("%s.tfm" % self
.name
, pykpathsea
.kpse_tfm_format
)
596 raise TFMError("cannot find %s.tfm" % self
.name
)
597 self
.tfmfile
= tfmfile(tfmpath
, debug
)
599 # We only check for equality of font checksums if none of them
600 # is zero. The case c == 0 happend in some VF files and
601 # according to the VFtoVP documentation, paragraph 40, a check
602 # is only performed if tfmfile.checksum > 0. Anyhow, being
603 # more generous here seems to be reasonable
604 if self
.tfmfile
.checksum
!= c
and self
.tfmfile
.checksum
!= 0 and c
!=0:
605 raise DVIError("check sums do not agree: %d vs. %d" %
606 (self
.tfmfile
.checksum
, c
))
608 # tfmfile.designsizeraw is the design size of the font as a fix_word
609 if abs(self
.tfmfile
.designsizeraw
- d
) > 2:
610 raise DVIError("design sizes do not agree: %d vs. %d" % (self
.tfmfile
.designsizeraw
, d
))
611 if q
< 0 or q
> 134217728:
612 raise DVIError("font '%s' not loaded: bad scale" % self
.name
)
613 if d
< 0 or d
> 134217728:
614 raise DVIError("font '%s' not loaded: bad design size" % self
.name
)
618 # for bookkeeping of used characters
619 self
.usedchars
= [0] * 256
622 return "font %s designed at %g tex pts used at %g tex pts" % (self
.name
,
623 16.0*self
.d
/16777216L,
624 16.0*self
.q
/16777216L)
630 """ return size of font in (PS) points """
631 # The factor 16L/16777216L=2**(-20) converts a fix_word (here self.q)
632 # to the corresponding float. Furthermore, we have to convert from TeX
633 # points to points, hence the factor 72/72.27.
634 return 16L*self
.q
/16777216L*72/72.27
636 def _convert(self
, width
):
637 return 16L*width
*self
.q
/16777216L
639 def getwidth(self
, charcode
):
640 return self
._convert
(self
.tfmfile
.width
[self
.tfmfile
.char_info
[charcode
].width_index
])
642 def getheight(self
, charcode
):
643 return self
._convert
(self
.tfmfile
.height
[self
.tfmfile
.char_info
[charcode
].height_index
])
645 def getdepth(self
, charcode
):
646 return self
._convert
(self
.tfmfile
.depth
[self
.tfmfile
.char_info
[charcode
].depth_index
])
648 def getitalic(self
, charcode
):
649 return self
._convert
(self
.tfmfile
.italic
[self
.tfmfile
.char_info
[charcode
].italic_index
])
651 def markcharused(self
, charcode
):
652 self
.usedchars
[charcode
] = 1
654 def mergeusedchars(self
, otherfont
):
655 for i
in range(len(self
.usedchars
)):
656 self
.usedchars
[i
] = self
.usedchars
[i
] or otherfont
.usedchars
[i
]
658 def clearusedchars(self
):
659 self
.usedchars
= [0] * 256
662 class type1font(font
):
663 def __init__(self
, name
, c
, q
, d
, fontmap
, debug
=0):
664 font
.__init
__(self
, name
, c
, q
, d
, debug
)
665 self
.fontmapping
= fontmap
.get(name
)
666 if self
.fontmapping
is None:
667 raise RuntimeError("no information for font '%s' found in font mapping file, aborting" % name
)
669 def getbasepsname(self
):
670 return self
.fontmapping
.basepsname
673 if self
.fontmapping
.reencodefont
:
674 return "%s-%s" % (self
.fontmapping
.basepsname
, self
.fontmapping
.reencodefont
)
676 return self
.fontmapping
.basepsname
678 def getfontfile(self
):
679 return self
.fontmapping
.fontfile
681 def getencoding(self
):
682 return self
.fontmapping
.reencodefont
684 def getencodingfile(self
):
685 return self
.fontmapping
.encodingfile
688 class virtualfont(font
):
689 def __init__(self
, name
, c
, q
, d
, fontmap
, debug
=0):
690 font
.__init
__(self
, name
, c
, q
, d
, debug
)
691 fontpath
= pykpathsea
.find_file(name
, pykpathsea
.kpse_vf_format
)
692 if fontpath
is None or not len(fontpath
):
694 self
.vffile
= vffile(fontpath
, self
.scale
, fontmap
, debug
> 1)
697 """ return fonts used in virtual font itself """
698 return self
.vffile
.getfonts()
700 def getchar(self
, cc
):
701 """ return dvi chunk corresponding to char code cc """
702 return self
.vffile
.getchar(cc
)
705 ##############################################################################
707 ##############################################################################
709 _DVI_CHARMIN
= 0 # typeset a character and move right (range min)
710 _DVI_CHARMAX
= 127 # typeset a character and move right (range max)
711 _DVI_SET1234
= 128 # typeset a character and move right
712 _DVI_SETRULE
= 132 # typeset a rule and move right
713 _DVI_PUT1234
= 133 # typeset a character
714 _DVI_PUTRULE
= 137 # typeset a rule
715 _DVI_NOP
= 138 # no operation
716 _DVI_BOP
= 139 # beginning of page
717 _DVI_EOP
= 140 # ending of page
718 _DVI_PUSH
= 141 # save the current positions (h, v, w, x, y, z)
719 _DVI_POP
= 142 # restore positions (h, v, w, x, y, z)
720 _DVI_RIGHT1234
= 143 # move right
721 _DVI_W0
= 147 # move right by w
722 _DVI_W1234
= 148 # move right and set w
723 _DVI_X0
= 152 # move right by x
724 _DVI_X1234
= 153 # move right and set x
725 _DVI_DOWN1234
= 157 # move down
726 _DVI_Y0
= 161 # move down by y
727 _DVI_Y1234
= 162 # move down and set y
728 _DVI_Z0
= 166 # move down by z
729 _DVI_Z1234
= 167 # move down and set z
730 _DVI_FNTNUMMIN
= 171 # set current font (range min)
731 _DVI_FNTNUMMAX
= 234 # set current font (range max)
732 _DVI_FNT1234
= 235 # set current font
733 _DVI_SPECIAL1234
= 239 # special (dvi extention)
734 _DVI_FNTDEF1234
= 243 # define the meaning of a font number
735 _DVI_PRE
= 247 # preamble
736 _DVI_POST
= 248 # postamble beginning
737 _DVI_POSTPOST
= 249 # postamble ending
739 _DVI_VERSION
= 2 # dvi version
741 # position variable indices
753 _READ_POST
= 4 # XXX not used
754 _READ_POSTPOST
= 5 # XXX not used
758 class DVIError(exceptions
.Exception): pass
760 # save and restore colors
762 class _savecolor(base
.PSOp
):
763 def outputPS(self
, file):
764 file.write("currentcolor currentcolorspace\n")
767 class _restorecolor(base
.PSOp
):
768 def outputPS(self
, file):
769 file.write("setcolorspace setcolor\n")
771 class _savetrafo(base
.PSOp
):
772 def outputPS(self
, file):
773 file.write("matrix currentmatrix\n")
776 class _restoretrafo(base
.PSOp
):
777 def outputPS(self
, file):
778 file.write("setmatrix\n")
783 def __init__(self
, filename
, fontmap
, debug
=0):
784 """ opens the dvi file and reads the preamble """
785 self
.filename
= filename
786 self
.fontmap
= fontmap
790 self
.activefont
= None
792 # stack of fonts and fontscale currently used (used for VFs)
796 # pointer to currently active page
799 # currently active output: show instance currently used and
800 # the corresponding type 1 font
801 self
.activeshow
= None
802 self
.activetype1font
= None
804 # stack for self.file, self.fonts and self.stack, needed for VF inclusion
807 self
.file = binfile(self
.filename
, "rb")
809 # currently read byte in file (for debugging output)
817 """ flush currently active string """
818 if self
.activeshow
is not None:
820 print "[%s]" % "".join([chr(char
) for char
in self
.activeshow
.chars
])
821 self
.actpage
.insert(self
.activeshow
)
822 self
.activeshow
= None
825 """ activate the font if is not yet active, closing a currently active
826 text object and flushing the output"""
827 if isinstance(self
.activefont
, type1font
):
829 if self
.activetype1font
!= self
.activefont
and self
.activefont
:
830 self
.actpage
.insert(_begintextobject())
831 self
.actpage
.insert(selectfont(self
.activefont
))
832 self
.activetype1font
= self
.activefont
836 if self
.activetype1font
:
837 self
.actpage
.insert(_endtextobject())
838 self
.activetype1font
= None
840 def putrule(self
, height
, width
, advancepos
=1):
842 x1
= self
.pos
[_POS_H
] * self
.conv
843 y1
= -self
.pos
[_POS_V
] * self
.conv
844 w
= width
* self
.conv
845 h
= height
* self
.conv
847 if height
> 0 and width
> 0:
849 pixelw
= int(width
*self
.trueconv
*self
.mag
/1000.0)
850 if pixelw
< width
*self
.conv
: pixelw
+= 1
851 pixelh
= int(height
*self
.trueconv
*self
.mag
/1000.0)
852 if pixelh
< height
*self
.conv
: pixelh
+= 1
854 print ("%d: %srule height %d, width %d (%dx%d pixels)" %
855 (self
.filepos
, advancepos
and "set" or "put", height
, width
, pixelh
, pixelw
))
856 self
.actpage
.fill(path
.rect_pt(x1
, y1
, w
, h
))
859 print ("%d: %srule height %d, width %d (invisible)" %
860 (self
.filepos
, advancepos
and "set" or "put", height
, width
))
864 print (" h:=%d+%d=%d, hh:=%d" %
865 (self
.pos
[_POS_H
], width
, self
.pos
[_POS_H
]+width
, 0))
866 self
.pos
[_POS_H
] += width
868 def putchar(self
, char
, advancepos
=1):
869 dx
= advancepos
and int(round(self
.activefont
.getwidth(char
)*self
.tfmconv
)) or 0
872 print ("%d: %schar%d h:=%d+%d=%d, hh:=%d" %
874 advancepos
and "set" or "put",
876 self
.pos
[_POS_H
], dx
, self
.pos
[_POS_H
]+dx
,
879 if isinstance(self
.activefont
, type1font
):
880 if self
.activeshow
is None:
882 self
.activeshow
= _show(self
.pos
[_POS_H
] * self
.conv
, -self
.pos
[_POS_V
] * self
.conv
)
883 width
= self
.activefont
.getwidth(char
) * self
.tfmconv
* self
.conv
884 height
= self
.activefont
.getheight(char
) * self
.tfmconv
* self
.conv
885 depth
= self
.activefont
.getdepth(char
) * self
.tfmconv
* self
.conv
886 self
.activeshow
.addchar(width
, height
, depth
, char
)
888 self
.activefont
.markcharused(char
)
889 self
.pos
[_POS_H
] += dx
891 # virtual font handling
892 afterpos
= list(self
.pos
)
893 afterpos
[_POS_H
] += dx
894 self
._push
_dvistring
(self
.activefont
.getchar(char
), self
.activefont
.getfonts(), afterpos
,
895 self
.activefont
.getsize())
902 def usefont(self
, fontnum
):
904 print ("%d: fntnum%i current font is %s" %
906 fontnum
, self
.fonts
[fontnum
].name
))
908 self
.activefont
= self
.fonts
[fontnum
]
911 def definefont(self
, cmdnr
, num
, c
, q
, d
, fontname
):
912 # cmdnr: type of fontdef command (only used for debugging output)
914 # q: scaling factor (fix_word)
915 # Note that q is actually s in large parts of the documentation.
916 # d: design size (fix_word)
919 font
= virtualfont(fontname
, c
, q
/self
.tfmconv
, d
/self
.tfmconv
, self
.fontmap
, self
.debug
> 1)
920 except (TypeError, RuntimeError):
921 font
= type1font(fontname
, c
, q
/self
.tfmconv
, d
/self
.tfmconv
, self
.fontmap
, self
.debug
> 1)
923 self
.fonts
[num
] = font
926 print "%d: fntdef%d %i: %s" % (self
.filepos
, cmdnr
, num
, fontname
)
928 # scale = round((1000.0*self.conv*q)/(self.trueconv*d))
930 # scalestring = scale!=1000 and " scaled %d" % scale or ""
931 # print ("Font %i: %s%s---loaded at size %d DVI units" %
932 # (num, fontname, scalestring, q))
934 # print " (this font is magnified %d%%)" % round(scale/10)
936 def special(self
, s
):
937 x
= self
.pos
[_POS_H
] * self
.conv
938 y
= -self
.pos
[_POS_V
] * self
.conv
940 print "%d: xxx '%s'" % (self
.filepos
, s
)
941 if not s
.startswith("PyX:"):
942 if s
.startswith("Warning:"):
943 sys
.stderr
.write("*** PyX Warning: ignoring special '%s'\n" % s
)
946 raise RuntimeError("the special '%s' cannot be handled by PyX, aborting" % s
)
948 # it is in general not safe to continue using the currently active font because
949 # the specials may involve some gsave/grestore operations
952 command
, args
= s
[4:].split()[0], s
[4:].split()[1:]
953 if command
=="color_begin":
955 c
= color
.cmyk(float(args
[1]), float(args
[2]), float(args
[3]), float(args
[4]))
956 elif args
[0]=="gray":
957 c
= color
.gray(float(args
[1]))
959 c
= color
.hsb(float(args
[1]), float(args
[2]), float(args
[3]))
961 c
= color
.rgb(float(args
[1]), float(args
[2]), float(args
[3]))
963 c
= color
.rgb(int(args
[1])/255.0, int(args
[2])/255.0, int(args
[3])/255.0)
964 elif args
[0]=="texnamed":
966 c
= getattr(color
.cmyk
, args
[1])
967 except AttributeError:
968 raise RuntimeError("unknown TeX color '%s', aborting" % args
[1])
970 raise RuntimeError("color model '%s' cannot be handled by PyX, aborting" % args
[0])
971 self
.actpage
.insert(_savecolor())
972 self
.actpage
.insert(c
)
973 elif command
=="color_end":
974 self
.actpage
.insert(_restorecolor())
975 elif command
=="rotate_begin":
976 self
.actpage
.insert(_savetrafo())
977 self
.actpage
.insert(trafo
.rotate_pt(float(args
[0]), x
, y
))
978 elif command
=="rotate_end":
979 self
.actpage
.insert(_restoretrafo())
980 elif command
=="scale_begin":
981 self
.actpage
.insert(_savetrafo())
982 self
.actpage
.insert(trafo
.scale_pt(float(args
[0]), float(args
[1]), x
, y
))
983 elif command
=="scale_end":
984 self
.actpage
.insert(_restoretrafo())
985 elif command
=="epsinclude":
989 name
, value
= arg
.split("=")
990 argdict
[name
] = value
992 # construct kwargs for epsfile constructor
994 epskwargs
["filename"] = argdict
["file"]
995 epskwargs
["bbox"] = bbox
.bbox_pt(float(argdict
["llx"]), float(argdict
["lly"]),
996 float(argdict
["urx"]), float(argdict
["ury"]))
997 if argdict
.has_key("width"):
998 epskwargs
["width"] = float(argdict
["width"]) * unit
.t_pt
999 if argdict
.has_key("height"):
1000 epskwargs
["height"] = float(argdict
["height"]) * unit
.t_pt
1001 if argdict
.has_key("clip"):
1002 epskwargs
["clip"] = int(argdict
["clip"])
1003 self
.actpage
.insert(epsfile
.epsfile(x
* unit
.t_pt
, y
* unit
.t_pt
, **epskwargs
))
1004 elif command
=="marker":
1006 raise RuntimeError("marker contains spaces")
1008 if c
not in string
.digits
+ string
.letters
+ "@":
1009 raise RuntimeError("marker contains invalid characters")
1010 if self
.actpage
.markers
.has_key(args
[0]):
1011 raise RuntimeError("marker name occurred several times")
1012 self
.actpage
.markers
[args
[0]] = x
* unit
.t_pt
, y
* unit
.t_pt
1014 raise RuntimeError("unknown PyX special '%s', aborting" % command
)
1017 # routines for pushing and popping different dvi chunks on the reader
1019 def _push_dvistring(self
, dvi
, fonts
, afterpos
, fontsize
):
1020 """ push dvi string with defined fonts on top of reader
1021 stack. Every positions gets scaled relatively by the factor
1022 scale. After the interpreting of the dvi chunk has been finished,
1023 continue with self.pos=afterpos. The designsize of the virtual
1024 font is passed as a fix_word
1029 print "executing new dvi chunk"
1030 self
.statestack
.append((self
.file, self
.fonts
, self
.activefont
, afterpos
, self
.stack
, self
.conv
, self
.tfmconv
))
1032 # units in vf files are relative to the size of the font and given as fix_words
1033 # which can be converted to floats by diving by 2**20
1035 self
.conv
= fontsize
/2**20
1036 rescale
= self
.conv
/oldconv
1038 self
.file = stringbinfile(dvi
)
1043 # rescale self.pos in order to be consistent with the new scaling
1044 self
.pos
= map(lambda x
, rescale
=rescale
:1.0*x
/rescale
, self
.pos
)
1046 # since tfmconv converts from tfm units to dvi units, rescale it as well
1047 self
.tfmconv
/= rescale
1051 def _pop_dvistring(self
):
1054 print "finished executing dvi chunk"
1056 self
.file, self
.fonts
, self
.activefont
, self
.pos
, self
.stack
, self
.conv
, self
.tfmconv
= self
.statestack
.pop()
1058 # routines corresponding to the different reader states of the dvi maschine
1060 def _read_pre(self
):
1063 self
.filepos
= afile
.tell()
1064 cmd
= afile
.readuchar()
1067 elif cmd
== _DVI_PRE
:
1068 if afile
.readuchar() != _DVI_VERSION
: raise DVIError
1069 num
= afile
.readuint32()
1070 den
= afile
.readuint32()
1071 self
.mag
= afile
.readuint32()
1073 # for the interpretation of all quantities, two conversion factors
1075 # - self.tfmconv (tfm units->dvi units)
1076 # - self.conv (dvi units-> (PostScript) points)
1078 self
.tfmconv
= (25400000.0/num
)*(den
/473628672.0)/16.0
1080 # calculate self.conv as described in the DVIType docu
1083 self
.resolution
= 300.0
1084 # self.trueconv = conv in DVIType docu
1085 self
.trueconv
= (num
/254000.0)*(self
.resolution
/den
)
1087 # self.conv is the conversion factor from the dvi units
1088 # to (PostScript) points. It consists of
1089 # - self.mag/1000.0: magstep scaling
1090 # - self.trueconv: conversion from dvi units to pixels
1091 # - 1/self.resolution: conversion from pixels to inch
1092 # - 72 : conversion from inch to points
1093 self
.conv
= self
.mag
/1000.0*self
.trueconv
/self
.resolution
*72
1095 comment
= afile
.read(afile
.readuchar())
1100 def readpage(self
, pageid
=None):
1101 """ reads a page from the dvi file
1103 This routine reads a page from the dvi file which is
1104 returned as a canvas. When there is no page left in the
1105 dvifile, None is returned and the file is closed properly."""
1109 self
.filepos
= self
.file.tell()
1110 cmd
= self
.file.readuchar()
1113 elif cmd
== _DVI_BOP
:
1115 ispageid
= [self
.file.readuint32() for i
in range(10)]
1116 #if ispageid[:3] != [ord("P"), ord("y"), ord("X")] or ispageid[4:] != [0, 0, 0, 0, 0, 0]:
1117 if pageid
is not None and ispageid
!= pageid
:
1118 raise DVIError("invalid pageid")
1120 print "%d: beginning of page %i" % (self
.filepos
, ispageid
[0])
1121 self
.file.readuint32()
1123 elif cmd
== _DVI_POST
:
1125 return None # nothing left
1129 actpage
= canvas
.canvas()
1130 self
.actpage
= actpage
# XXX should be removed ...
1131 self
.actpage
.markers
= {}
1132 self
.pos
= [0, 0, 0, 0, 0, 0]
1133 self
.activetype1font
= None
1135 # Since we do not know which dvi pages the actual PS file contains later on,
1136 # we have to keep track of used char informations separately for each dvi page.
1137 # In order to do so, the already defined fonts have to be copied and their
1138 # used char informations have to be reset
1139 for nr
in self
.fonts
.keys():
1140 self
.fonts
[nr
] = copy
.copy(self
.fonts
[nr
])
1141 self
.fonts
[nr
].clearusedchars()
1145 self
.filepos
= afile
.tell()
1147 cmd
= afile
.readuchar()
1148 except struct
.error
:
1149 # we most probably (if the dvi file is not corrupt) hit the end of a dvi chunk,
1150 # so we have to continue with the rest of the dvi file
1151 self
._pop
_dvistring
()
1155 if cmd
>= _DVI_CHARMIN
and cmd
<= _DVI_CHARMAX
:
1157 elif cmd
>= _DVI_SET1234
and cmd
< _DVI_SET1234
+ 4:
1158 self
.putchar(afile
.readint(cmd
- _DVI_SET1234
+ 1))
1159 elif cmd
== _DVI_SETRULE
:
1160 self
.putrule(afile
.readint32(), afile
.readint32())
1161 elif cmd
>= _DVI_PUT1234
and cmd
< _DVI_PUT1234
+ 4:
1162 self
.putchar(afile
.readint(cmd
- _DVI_PUT1234
+ 1), advancepos
=0)
1163 elif cmd
== _DVI_PUTRULE
:
1164 self
.putrule(afile
.readint32(), afile
.readint32(), 0)
1165 elif cmd
== _DVI_EOP
:
1168 print "%d: eop" % self
.filepos
1171 elif cmd
== _DVI_PUSH
:
1172 self
.stack
.append(list(self
.pos
))
1174 print "%d: push" % self
.filepos
1175 print ("level %d:(h=%d,v=%d,w=%d,x=%d,y=%d,z=%d,hh=,vv=)" %
1176 (( len(self
.stack
)-1,)+tuple(self
.pos
)))
1177 elif cmd
== _DVI_POP
:
1179 self
.pos
= self
.stack
.pop()
1181 print "%d: pop" % self
.filepos
1182 print ("level %d:(h=%d,v=%d,w=%d,x=%d,y=%d,z=%d,hh=,vv=)" %
1183 (( len(self
.stack
),)+tuple(self
.pos
)))
1184 elif cmd
>= _DVI_RIGHT1234
and cmd
< _DVI_RIGHT1234
+ 4:
1186 dh
= afile
.readint(cmd
- _DVI_RIGHT1234
+ 1, 1)
1188 print ("%d: right%d %d h:=%d%+d=%d, hh:=" %
1190 cmd
- _DVI_RIGHT1234
+ 1,
1194 self
.pos
[_POS_H
]+dh
))
1195 self
.pos
[_POS_H
] += dh
1196 elif cmd
== _DVI_W0
:
1199 print ("%d: w0 %d h:=%d%+d=%d, hh:=" %
1204 self
.pos
[_POS_H
]+self
.pos
[_POS_W
]))
1205 self
.pos
[_POS_H
] += self
.pos
[_POS_W
]
1206 elif cmd
>= _DVI_W1234
and cmd
< _DVI_W1234
+ 4:
1208 self
.pos
[_POS_W
] = afile
.readint(cmd
- _DVI_W1234
+ 1, 1)
1210 print ("%d: w%d %d h:=%d%+d=%d, hh:=" %
1212 cmd
- _DVI_W1234
+ 1,
1216 self
.pos
[_POS_H
]+self
.pos
[_POS_W
]))
1217 self
.pos
[_POS_H
] += self
.pos
[_POS_W
]
1218 elif cmd
== _DVI_X0
:
1220 self
.pos
[_POS_H
] += self
.pos
[_POS_X
]
1221 elif cmd
>= _DVI_X1234
and cmd
< _DVI_X1234
+ 4:
1223 self
.pos
[_POS_X
] = afile
.readint(cmd
- _DVI_X1234
+ 1, 1)
1224 self
.pos
[_POS_H
] += self
.pos
[_POS_X
]
1225 elif cmd
>= _DVI_DOWN1234
and cmd
< _DVI_DOWN1234
+ 4:
1227 dv
= afile
.readint(cmd
- _DVI_DOWN1234
+ 1, 1)
1229 print ("%d: down%d %d v:=%d%+d=%d, vv:=" %
1231 cmd
- _DVI_DOWN1234
+ 1,
1235 self
.pos
[_POS_V
]+dv
))
1236 self
.pos
[_POS_V
] += dv
1237 elif cmd
== _DVI_Y0
:
1240 print ("%d: y0 %d v:=%d%+d=%d, vv:=" %
1245 self
.pos
[_POS_V
]+self
.pos
[_POS_Y
]))
1246 self
.pos
[_POS_V
] += self
.pos
[_POS_Y
]
1247 elif cmd
>= _DVI_Y1234
and cmd
< _DVI_Y1234
+ 4:
1249 self
.pos
[_POS_Y
] = afile
.readint(cmd
- _DVI_Y1234
+ 1, 1)
1251 print ("%d: y%d %d v:=%d%+d=%d, vv:=" %
1253 cmd
- _DVI_Y1234
+ 1,
1257 self
.pos
[_POS_V
]+self
.pos
[_POS_Y
]))
1258 self
.pos
[_POS_V
] += self
.pos
[_POS_Y
]
1259 elif cmd
== _DVI_Z0
:
1261 self
.pos
[_POS_V
] += self
.pos
[_POS_Z
]
1262 elif cmd
>= _DVI_Z1234
and cmd
< _DVI_Z1234
+ 4:
1264 self
.pos
[_POS_Z
] = afile
.readint(cmd
- _DVI_Z1234
+ 1, 1)
1265 self
.pos
[_POS_V
] += self
.pos
[_POS_Z
]
1266 elif cmd
>= _DVI_FNTNUMMIN
and cmd
<= _DVI_FNTNUMMAX
:
1267 self
.usefont(cmd
- _DVI_FNTNUMMIN
)
1268 elif cmd
>= _DVI_FNT1234
and cmd
< _DVI_FNT1234
+ 4:
1269 self
.usefont(afile
.readint(cmd
- _DVI_FNT1234
+ 1, 1))
1270 elif cmd
>= _DVI_SPECIAL1234
and cmd
< _DVI_SPECIAL1234
+ 4:
1271 self
.special(afile
.read(afile
.readint(cmd
- _DVI_SPECIAL1234
+ 1)))
1272 elif cmd
>= _DVI_FNTDEF1234
and cmd
< _DVI_FNTDEF1234
+ 4:
1273 if cmd
== _DVI_FNTDEF1234
:
1274 num
= afile
.readuchar()
1275 elif cmd
== _DVI_FNTDEF1234
+1:
1276 num
= afile
.readuint16()
1277 elif cmd
== _DVI_FNTDEF1234
+2:
1278 num
= afile
.readuint24()
1279 elif cmd
== _DVI_FNTDEF1234
+3:
1280 # Cool, here we have according to docu a signed int. Why?
1281 num
= afile
.readint32()
1282 self
.definefont(cmd
-_DVI_FNTDEF1234
+1,
1287 afile
.read(afile
.readuchar()+afile
.readuchar()))
1292 ##############################################################################
1294 ##############################################################################
1296 _VF_LONG_CHAR
= 242 # character packet (long version)
1297 _VF_FNTDEF1234
= _DVI_FNTDEF1234
# font definition
1298 _VF_PRE
= _DVI_PRE
# preamble
1299 _VF_POST
= _DVI_POST
# postamble
1301 _VF_ID
= 202 # VF id byte
1303 class VFError(exceptions
.Exception): pass
1306 def __init__(self
, filename
, scale
, fontmap
, debug
=0):
1307 self
.filename
= filename
1309 self
.fontmap
= fontmap
1311 self
.fonts
= {} # used fonts
1312 self
.widths
= {} # widths of defined chars
1313 self
.chardefs
= {} # dvi chunks for defined chars
1315 afile
= binfile(self
.filename
, "rb")
1317 cmd
= afile
.readuchar()
1319 if afile
.readuchar() != _VF_ID
: raise VFError
1320 comment
= afile
.read(afile
.readuchar())
1321 self
.cs
= afile
.readuint32()
1322 self
.ds
= afile
.readuint32()
1327 cmd
= afile
.readuchar()
1328 if cmd
>= _VF_FNTDEF1234
and cmd
< _VF_FNTDEF1234
+ 4:
1330 if cmd
== _VF_FNTDEF1234
:
1331 num
= afile
.readuchar()
1332 elif cmd
== _VF_FNTDEF1234
+1:
1333 num
= afile
.readuint16()
1334 elif cmd
== _VF_FNTDEF1234
+2:
1335 num
= afile
.readuint24()
1336 elif cmd
== _VF_FNTDEF1234
+3:
1337 num
= afile
.readint32()
1338 c
= afile
.readint32()
1339 s
= afile
.readint32() # relative scaling used for font (fix_word)
1340 d
= afile
.readint32() # design size of font
1341 fontname
= afile
.read(afile
.readuchar()+afile
.readuchar())
1343 # rescaled size of font: s is relative to the scaling
1344 # of the virtual font itself. Note that realscale has
1345 # to be a fix_word (like s)
1346 # Furthermore we have to correct for self.tfmconv
1348 reals
= int(self
.scale
* float(fix_word(self
.ds
))*s
)
1349 # print ("defining font %s -- VF scale: %g, VF design size: %g, relative font size: %g => real size: %g" %
1350 # (fontname, self.scale, fix_word(self.ds), fix_word(s), fix_word(reals))
1354 # XXX allow for virtual fonts here too
1355 self
.fonts
[num
] = type1font(fontname
, c
, reals
, d
, self
.fontmap
, self
.debug
> 1)
1356 elif cmd
== _VF_LONG_CHAR
:
1357 # character packet (long form)
1358 pl
= afile
.readuint32() # packet length
1359 cc
= afile
.readuint32() # char code (assumed unsigned, but anyhow only 0 <= cc < 255 is actually used)
1360 tfm
= afile
.readuint24() # character width
1361 dvi
= afile
.read(pl
) # dvi code of character
1362 self
.widths
[cc
] = tfm
1363 self
.chardefs
[cc
] = dvi
1364 elif cmd
< _VF_LONG_CHAR
:
1365 # character packet (short form)
1366 cc
= afile
.readuchar() # char code
1367 tfm
= afile
.readuint24() # character width
1368 dvi
= afile
.read(cmd
)
1369 self
.widths
[cc
] = tfm
1370 self
.chardefs
[cc
] = dvi
1371 elif cmd
== _VF_POST
:
1381 def getchar(self
, cc
):
1382 return self
.chardefs
[cc
]