pyx/canvas.py

   1 #!/usr/bin/env python
   2 # -*- coding: ISO-8859-1 -*-
   3 #
   4 #
   5 # Copyright (C) 2002-2004 Jörg Lehmann <joergl@users.sourceforge.net>
   6 # Copyright (C) 2002-2004 André Wobst <wobsta@users.sourceforge.net>
   7 #
   8 # This file is part of PyX (http://pyx.sourceforge.net/).
   9 #
  10 # PyX is free software; you can redistribute it and/or modify
  11 # it under the terms of the GNU General Public License as published by
  12 # the Free Software Foundation; either version 2 of the License, or
  13 # (at your option) any later version.
  14 #
  15 # PyX is distributed in the hope that it will be useful,
  16 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  17 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18 # GNU General Public License for more details.
  19 #
  20 # You should have received a copy of the GNU General Public License
  21 # along with PyX; if not, write to the Free Software
  22 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  23
  24 # XXX what are the correct base classes of clip and pattern
  25
  26 """The canvas module provides a PostScript canvas class and related classes
  27
  28 A canvas holds a collection of all elements that should be displayed together
  29 with their attributes.
  30 """
  31
  32 import sys, cStringIO, time
  33 import attr, base,  bbox, deco, unit, prolog, style, trafo, version
  34
  35 # temporary for pdf fonts:
  36 import zlib
  37 from t1strip import fullfont
  38 import pykpathsea
  39
  40 try:
  41     enumerate([])
  42 except NameError:
  43     # fallback implementation for Python 2.2. and below
  44     def enumerate(list):
  45         return zip(xrange(len(list)), list)
  46
  47 # known paperformats as tuple (width, height)
  48
  49 _paperformats = { "A4"      : (210 * unit.t_mm,   297  * unit.t_mm),
  50                   "A3"      : (297 * unit.t_mm,   420  * unit.t_mm),
  51                   "A2"      : (420 * unit.t_mm,   594  * unit.t_mm),
  52                   "A1"      : (594 * unit.t_mm,   840  * unit.t_mm),
  53                   "A0"      : (840 * unit.t_mm,   1188 * unit.t_mm),
  54                   "A0b"     : (910 * unit.t_mm,   1370 * unit.t_mm),
  55                   "Letter"  : (8.5 * unit.t_inch, 11   * unit.t_inch),
  56                   "Legal"   : (8.5 * unit.t_inch, 14   * unit.t_inch)}
  57
  58 #
  59 # clipping class
  60 #
  61
  62 class clip(base.PSCmd):
  63
  64     """class for use in canvas constructor which clips to a path"""
  65
  66     def __init__(self, path):
  67         """construct a clip instance for a given path"""
  68         self.path = path
  69
  70     def bbox(self):
  71         # as a PSCmd a clipping path has NO influence on the bbox...
  72         return None
  73
  74     def clipbbox(self):
  75         # ... but for clipping, we nevertheless need the bbox
  76         return self.path.bbox()
  77
  78     def outputPS(self, file):
  79         file.write("newpath\n")
  80         self.path.outputPS(file)
  81         file.write("clip\n")
  82
  83     def outputPDF(self, file):
  84         self.path.outputPDF(file)
  85         file.write("W n\n")
  86
  87 #
  88 # general canvas class
  89 #
  90
  91 class _canvas(base.PSCmd):
  92
  93     """a canvas is a collection of PSCmds together with PSAttrs"""
  94
  95     def __init__(self, attrs=[], texrunner=None):
  96
  97         """construct a canvas
  98
  99         The canvas can be modfied by supplying args, which have
 100         to be instances of one of the following classes:
 101          - trafo.trafo (leading to a global transformation of the canvas)
 102          - canvas.clip (clips the canvas)
 103          - base.PathStyle (sets some global attributes of the canvas)
 104
 105         Note that, while the first two properties are fixed for the
 106         whole canvas, the last one can be changed via canvas.set().
 107
 108         The texrunner instance used for the text method can be specified
 109         using the texrunner argument. It defaults to text.defaulttexrunner
 110
 111         """
 112
 113         self.PSOps     = []
 114         self.trafo     = trafo.trafo()
 115         self.clipbbox  = None
 116         if texrunner is not None:
 117             self.texrunner = texrunner
 118         else:
 119             # prevent cyclic imports
 120             import text
 121             self.texrunner = text.defaulttexrunner
 122
 123         for attr in attrs:
 124             if isinstance(attr, trafo.trafo_pt):
 125                 self.trafo = self.trafo*attr
 126                 self.PSOps.append(attr)
 127             elif isinstance(attr, clip):
 128                 if self.clipbbox is None:
 129                     self.clipbbox = attr.clipbbox().transformed(self.trafo)
 130                 else:
 131                     self.clippbox *= attr.clipbbox().transformed(self.trafo)
 132                 self.PSOps.append(attr)
 133             else:
 134                 self.set([attr])
 135
 136     def bbox(self):
 137         """returns bounding box of canvas"""
 138         obbox = None
 139         for cmd in self.PSOps:
 140             if isinstance(cmd, base.PSCmd):
 141                 abbox = cmd.bbox()
 142                 if obbox is None:
 143                     obbox = abbox
 144                 elif abbox is not None:
 145                     obbox += abbox
 146
 147         # transform according to our global transformation and
 148         # intersect with clipping bounding box (which have already been
 149         # transformed in canvas.__init__())
 150         if obbox is not None and self.clipbbox is not None:
 151             return obbox.transformed(self.trafo)*self.clipbbox
 152         elif obbox is not None:
 153             return obbox.transformed(self.trafo)
 154         else:
 155             return self.clipbbox
 156
 157     def prolog(self):
 158         result = []
 159         for cmd in self.PSOps:
 160             result.extend(cmd.prolog())
 161         return result
 162
 163     def outputPS(self, file):
 164         if self.PSOps:
 165             file.write("gsave\n")
 166             for cmd in self.PSOps:
 167                 cmd.outputPS(file)
 168             file.write("grestore\n")
 169
 170     def outputPDF(self, file):
 171         if self.PSOps:
 172             file.write("q\n") # gsave
 173             for cmd in self.PSOps:
 174                 cmd.outputPDF(file)
 175             file.write("Q\n") # grestore
 176
 177     def insert(self, PSOp, attrs=[]):
 178         """insert PSOp in the canvas.
 179
 180         If attrss are given, a canvas containing the PSOp is inserted applying attrs.
 181
 182         returns the PSOp
 183
 184         """
 185
 186         # XXX check for PSOp
 187
 188         if attrs:
 189             sc = _canvas(attrs)
 190             sc.insert(PSOp)
 191             self.PSOps.append(sc)
 192         else:
 193             self.PSOps.append(PSOp)
 194
 195         return PSOp
 196
 197     def set(self, attrs):
 198         """sets styles args globally for the rest of the canvas
 199         """
 200
 201         attr.checkattrs(attrs, [style.strokestyle, style.fillstyle])
 202         for astyle in attrs:
 203             self.insert(astyle)
 204
 205     def draw(self, path, attrs):
 206         """draw path on canvas using the style given by args
 207
 208         The argument attrs consists of PathStyles, which modify
 209         the appearance of the path, PathDecos, which add some new
 210         visual elements to the path, or trafos, which are applied
 211         before drawing the path.
 212
 213         """
 214
 215         attrs = attr.mergeattrs(attrs)
 216         attr.checkattrs(attrs, [deco.deco, style.fillstyle, style.strokestyle, trafo.trafo_pt])
 217
 218         for t in attr.getattrs(attrs, [trafo.trafo_pt]):
 219             path = path.transformed(t)
 220
 221         dp = deco.decoratedpath(path)
 222
 223         # set global styles
 224         dp.styles = attr.getattrs(attrs, [style.fillstyle, style.strokestyle])
 225
 226         # add path decorations and modify path accordingly
 227         for adeco in attr.getattrs(attrs, [deco.deco]):
 228             dp = adeco.decorate(dp)
 229
 230         self.insert(dp)
 231
 232     def stroke(self, path, attrs=[]):
 233         """stroke path on canvas using the style given by args
 234
 235         The argument attrs consists of PathStyles, which modify
 236         the appearance of the path, PathDecos, which add some new
 237         visual elements to the path, or trafos, which are applied
 238         before drawing the path.
 239
 240         """
 241
 242         self.draw(path, [deco.stroked]+list(attrs))
 243
 244     def fill(self, path, attrs=[]):
 245         """fill path on canvas using the style given by args
 246
 247         The argument attrs consists of PathStyles, which modify
 248         the appearance of the path, PathDecos, which add some new
 249         visual elements to the path, or trafos, which are applied
 250         before drawing the path.
 251
 252         """
 253
 254         self.draw(path, [deco.filled]+list(attrs))
 255
 256     def settexrunner(self, texrunner):
 257         """sets the texrunner to be used to within the text and text_pt methods"""
 258
 259         self.texrunner = texrunner
 260
 261     def text(self, x, y, atext, *args, **kwargs):
 262         """insert a text into the canvas
 263
 264         inserts a textbox created by self.texrunner.text into the canvas
 265
 266         returns the inserted textbox"""
 267
 268         return self.insert(self.texrunner.text(x, y, atext, *args, **kwargs))
 269
 270
 271     def text_pt(self, x, y, atext, *args):
 272         """insert a text into the canvas
 273
 274         inserts a textbox created by self.texrunner.text_pt into the canvas
 275
 276         returns the inserted textbox"""
 277
 278         return self.insert(self.texrunner.text_pt(x, y, atext, *args))
 279
 280 #
 281 # canvas for patterns
 282 #
 283
 284 class pattern(_canvas, attr.exclusiveattr, style.fillstyle):
 285
 286     def __init__(self, painttype=1, tilingtype=1, xstep=None, ystep=None, bbox=None, trafo=None):
 287         attr.exclusiveattr.__init__(self, pattern)
 288         _canvas.__init__(self)
 289         attr.exclusiveattr.__init__(self, pattern)
 290         self.id = "pattern%d" % id(self)
 291         if painttype not in (1,2):
 292             raise ValueError("painttype must be 1 or 2")
 293         self.painttype = painttype
 294         if tilingtype not in (1,2,3):
 295             raise ValueError("tilingtype must be 1, 2 or 3")
 296         self.tilingtype = tilingtype
 297         self.xstep = xstep
 298         self.ystep = ystep
 299         self.patternbbox = bbox
 300         self.patterntrafo = trafo
 301
 302     def bbox(self):
 303         return None
 304
 305     def outputPS(self, file):
 306         file.write("%s setpattern\n" % self.id)
 307
 308     def prolog(self):
 309         realpatternbbox = _canvas.bbox(self)
 310         if self.xstep is None:
 311            xstep = unit.topt(realpatternbbox.width())
 312         else:
 313            xstep = unit.topt(unit.length(self.xstep))
 314         if self.ystep is None:
 315             ystep = unit.topt(realpatternbbox.height())
 316         else:
 317            ystep = unit.topt(unit.length(self.ystep))
 318         if not xstep:
 319             raise ValueError("xstep in pattern cannot be zero")
 320         if not ystep:
 321             raise ValueError("ystep in pattern cannot be zero")
 322         patternbbox = self.patternbbox or realpatternbbox.enlarged(5*unit.pt)
 323
 324         patternprefix = "\n".join(("<<",
 325                                    "/PatternType 1",
 326                                    "/PaintType %d" % self.painttype,
 327                                    "/TilingType %d" % self.tilingtype,
 328                                    "/BBox[%s]" % str(patternbbox),
 329                                    "/XStep %g" % xstep,
 330                                    "/YStep %g" % ystep,
 331                                    "/PaintProc {\nbegin\n"))
 332         stringfile = cStringIO.StringIO()
 333         _canvas.outputPS(self, stringfile)
 334         patternproc = stringfile.getvalue()
 335         stringfile.close()
 336         patterntrafostring = self.patterntrafo is None and "matrix" or str(self.patterntrafo)
 337         patternsuffix = "end\n} bind\n>>\n%s\nmakepattern" % patterntrafostring
 338
 339         pr = _canvas.prolog(self)
 340         pr.append(prolog.definition(self.id, "".join((patternprefix, patternproc, patternsuffix))))
 341         return pr
 342
 343 pattern.clear = attr.clearclass(pattern)
 344
 345 # helper function
 346
 347 def calctrafo(abbox, paperformat, margin, rotated, fittosize):
 348     """ calculate a trafo which rotates and fits a canvas with
 349     bounding box abbox on the given paperformat with a margin on all
 350     sides"""
 351     margin = unit.length(margin)
 352     atrafo = None     # global transformation of canvas
 353
 354     if rotated:
 355         atrafo = trafo.rotate(90, *abbox.center())
 356
 357     if paperformat:
 358         # center (optionally rotated) output on page
 359         try:
 360             paperwidth, paperheight = _paperformats[paperformat.capitalize()]
 361         except KeyError:
 362             raise KeyError, "unknown paperformat '%s'" % paperformat
 363
 364         paperwidth -= 2*margin
 365         paperheight -= 2*margin
 366
 367         if not atrafo: atrafo = trafo.trafo()
 368
 369         atrafo = atrafo.translated(margin + 0.5*(paperwidth  - abbox.width())  - abbox.left(),
 370                                    margin + 0.5*(paperheight - abbox.height()) - abbox.bottom())
 371
 372         if fittosize:
 373             # scale output to pagesize - margins
 374             if 2*margin > min(paperwidth, paperheight):
 375                 raise RuntimeError("Margins too broad for selected paperformat. Aborting.")
 376
 377             if rotated:
 378                 sfactor = min(unit.topt(paperheight)/unit.topt(abbox.width()),
 379                               unit.topt(paperwidth)/unit.topt(abbox.height()))
 380             else:
 381                 sfactor = min(unit.topt(paperwidth)/unit.topt(abbox.width()),
 382                               unit.topt(paperheight)/unit.topt(abbox.height()))
 383
 384             atrafo = atrafo.scaled(sfactor, sfactor, margin + 0.5*paperwidth, margin + 0.5*paperheight)
 385     elif fittosize:
 386         raise ValueError("must specify paper size for fittosize")
 387
 388     return atrafo
 389
 390 #
 391 # The main canvas class
 392 #
 393
 394 class canvas(_canvas):
 395
 396     """a canvas is a collection of PSCmds together with PSAttrs"""
 397
 398     def writeEPSfile(self, filename, paperformat=None, rotated=0, fittosize=0, margin=1 * unit.t_cm,
 399                     bbox=None, bboxenlarge=1 * unit.t_pt):
 400         """write canvas to EPS file
 401
 402         If paperformat is set to a known paperformat, the output will be centered on
 403         the page.
 404
 405         If rotated is set, the output will first be rotated by 90 degrees.
 406
 407         If fittosize is set, then the output is scaled to the size of the
 408         page (minus margin). In that case, the paperformat the specification
 409         of the paperformat is obligatory.
 410
 411         The bbox parameter overrides the automatic bounding box determination.
 412         bboxenlarge may be used to enlarge the bbox of the canvas (or the
 413         manually specified bbox).
 414         """
 415
 416         if filename[-4:]!=".eps":
 417             filename = filename + ".eps"
 418
 419         try:
 420             file = open(filename, "w")
 421         except IOError:
 422             raise IOError("cannot open output file")
 423
 424         abbox = bbox is not None and bbox or self.bbox()
 425         abbox.enlarge(bboxenlarge)
 426         ctrafo = calctrafo(abbox, paperformat, margin, rotated, fittosize)
 427
 428         # if there has been a global transformation, adjust the bounding box
 429         # accordingly
 430         if ctrafo: abbox.transform(ctrafo)
 431
 432         file.write("%!PS-Adobe-3.0 EPSF 3.0\n")
 433         abbox.outputPS(file)
 434         file.write("%%%%Creator: PyX %s\n" % version.version)
 435         file.write("%%%%Title: %s\n" % filename)
 436         file.write("%%%%CreationDate: %s\n" %
 437                    time.asctime(time.localtime(time.time())))
 438         file.write("%%EndComments\n")
 439
 440         file.write("%%BeginProlog\n")
 441
 442         mergedprolog = []
 443
 444         for pritem in self.prolog():
 445             for mpritem in mergedprolog:
 446                 if mpritem.merge(pritem) is None: break
 447             else:
 448                 mergedprolog.append(pritem)
 449
 450         for pritem in mergedprolog:
 451             pritem.outputPS(file)
 452
 453         file.write("%%EndProlog\n")
 454
 455         # apply a possible global transformation
 456         if ctrafo: ctrafo.outputPS(file)
 457
 458         file.write("%f setlinewidth\n" % unit.topt(style.linewidth.normal))
 459
 460         # here comes the actual content
 461         self.outputPS(file)
 462
 463         file.write("showpage\n")
 464         file.write("%%Trailer\n")
 465         file.write("%%EOF\n")
 466
 467     def writePDFfile(self, filename, paperformat=None, rotated=0, fittosize=0, margin=1 * unit.t_cm,
 468                     bbox=None, bboxenlarge=1 * unit.t_pt):
 469         sys.stderr.write("*** PyX Warning: writePDFfile is experimental and supports only a subset of PyX's features\n")
 470
 471         if filename[-4:]!=".pdf":
 472             filename = filename + ".pdf"
 473
 474         try:
 475             file = open(filename, "wb")
 476         except IOError:
 477             raise IOError("cannot open output file")
 478
 479         abbox = bbox is not None and bbox or self.bbox()
 480         abbox.enlarge(bboxenlarge)
 481
 482         ctrafo = calctrafo(abbox, paperformat, margin, rotated, fittosize)
 483
 484         # if there has been a global transformation, adjust the bounding box
 485         # accordingly
 486         if ctrafo: abbox.transform(ctrafo)
 487
 488         mergedprolog = []
 489
 490         for pritem in self.prolog():
 491             for mpritem in mergedprolog:
 492                 if mpritem.merge(pritem) is None: break
 493             else:
 494                 mergedprolog.append(pritem)
 495
 496         file.write("%%PDF-1.4\n%%%s%s%s%s\n" % (chr(195), chr(182), chr(195), chr(169)))
 497         reflist = [file.tell()]
 498         file.write("1 0 obj\n"
 499                    "<<\n"
 500                    "/Type /Catalog\n"
 501                    "/Pages 2 0 R\n"
 502                    ">>\n"
 503                    "endobj\n")
 504         reflist.append(file.tell())
 505         file.write("2 0 obj\n"
 506                    "<<\n"
 507                    "/Type /Pages\n"
 508                    "/Kids [3 0 R]\n"
 509                    "/Count 1\n"
 510                    ">>\n"
 511                    "endobj\n")
 512         reflist.append(file.tell())
 513         file.write("3 0 obj\n"
 514                    "<<\n"
 515                    "/Type /Page\n"
 516                    "/Parent 2 0 R\n")
 517         abbox.outputPDF(file)
 518         file.write("/Contents 4 0 R\n"
 519                    "/Resources <<\n")
 520         fontstartref = 5
 521
 522         fontnr = 0
 523         if len([pritem for pritem in mergedprolog if isinstance(pritem, prolog.fontdefinition)]):
 524             file.write("/Font\n"
 525                        "<<\n")
 526             for pritem in mergedprolog:
 527                 if isinstance(pritem, prolog.fontdefinition):
 528                     fontnr += 1
 529                     file.write("/%s %d 0 R\n" % (pritem.font.getpsname(), fontnr+fontstartref))
 530                     fontnr += 3 # further objects due to a font
 531             file.write(">>\n")
 532
 533         file.write(">>\n"
 534                    ">>\n"
 535                    "endobj\n")
 536         reflist.append(file.tell())
 537         file.write("4 0 obj\n"
 538                    "<< /Length 5 0 R >>\n"
 539                    "stream\n")
 540         streamstartpos = file.tell()
 541
 542         # apply a possible global transformation
 543         if ctrafo: ctrafo.outputPDF(file)
 544         style.linewidth.normal.outputPDF(file)
 545
 546         self.outputPDF(file)
 547         streamendpos = file.tell()
 548         file.write("endstream\n"
 549                    "endobj\n")
 550         reflist.append(file.tell())
 551         file.write("5 0 obj\n"
 552                    "%s\n"
 553                    "endobj\n" % (streamendpos - streamstartpos))
 554
 555         fontnr = 0
 556         for pritem in mergedprolog:
 557             if isinstance(pritem, prolog.fontdefinition):
 558                 fontnr += 1
 559                 reflist.append(file.tell())
 560                 file.write("%d 0 obj\n"
 561                            "<<\n"
 562                            "/Type /Font\n"
 563                            "/Subtype /Type1\n"
 564                            "/Name /%s\n"
 565                            "/BaseFont /%s\n"
 566                            "/FirstChar 0\n"
 567                            "/LastChar 255\n"
 568                            "/Widths %d 0 R\n"
 569                            "/FontDescriptor %d 0 R\n"
 570                            "/Encoding /StandardEncoding\n" # FIXME
 571                            ">>\n"
 572                            "endobj\n" % (fontnr+fontstartref, pritem.font.getpsname(), pritem.font.getbasepsname(),
 573                                          fontnr+fontstartref+1, fontnr+fontstartref+2))
 574                 fontnr += 1
 575                 reflist.append(file.tell())
 576                 file.write("%d 0 obj\n"
 577                            "[\n" % (fontnr+fontstartref))
 578                 for i in range(256):
 579                     try:
 580                         width = pritem.font.getwidth_pt(i)*1000/pritem.font.getsize_pt()
 581                     except:
 582                         width = 0
 583                     file.write("%f\n" % width)
 584                 file.write("]\n"
 585                            "endobj\n")
 586                 if pritem.filename:
 587                     fontnr += 1
 588                     reflist.append(file.tell())
 589                     file.write("%d 0 obj\n"
 590                                "<<\n"
 591                                "/Type /FontDescriptor\n"
 592                                "/FontName /%s\n"
 593                                "/Flags 4\n" # FIXME
 594                                "/FontBBox [-10 -10 1000 1000]\n" # FIXME
 595                                "/ItalicAngle 0\n" # FIXME
 596                                "/Ascent 20\n" # FIXME
 597                                "/Descent -5\n" # FIXME
 598                                "/CapHeight 15\n" # FIXME
 599                                "/StemV 3\n" # FIXME
 600                                "/FontFile %d 0 R\n" # FIXME
 601                                # "/CharSet \n" # fill in when stripping
 602                                ">>\n"
 603                                "endobj\n" % (fontnr+fontstartref, pritem.font.getbasepsname(),
 604                                              fontnr+fontstartref+1))
 605
 606                     fontnr += 1
 607                     reflist.append(file.tell())
 608
 609                     fontdata = open(pykpathsea.find_file(pritem.filename, pykpathsea.kpse_type1_format)).read()
 610                     if fontdata[0:2] != fullfont._PFB_ASCII:
 611                         raise RuntimeError("PFB_ASCII mark expected")
 612                     length1 = fullfont.pfblength(fontdata[2:6])
 613                     if fontdata[6+length1:8+length1] != fullfont._PFB_BIN:
 614                         raise RuntimeError("PFB_BIN mark expected")
 615                     length2 = fullfont.pfblength(fontdata[8+length1:12+length1])
 616                     if fontdata[12+length1+length2:14+length1+length2] != fullfont._PFB_ASCII:
 617                         raise RuntimeError("PFB_ASCII mark expected")
 618                     length3 = fullfont.pfblength(fontdata[14+length1+length2:18+length1+length2])
 619                     if fontdata[18+length1+length2+length3:20+length1+length2+length3] != fullfont._PFB_DONE:
 620                         raise RuntimeError("PFB_DONE mark expected")
 621                     if len(fontdata) != 20 + length1 + length2 + length3:
 622                         raise RuntimeError("end of pfb file expected")
 623
 624                     # we might be allowed to skip the third part ...
 625                     if fontdata[18+length1+length2:18+length1+length2+length3].replace("\n", "").replace("\r", "").replace("\t", "").replace(" ", "") == "0"*512 + "cleartomark":
 626                         length3 = 0
 627
 628                     uncompresseddata = fontdata[6:6+length1] + fontdata[12+length1:12+length1+length2] + fontdata[18+length1+length2:18+length1+length2+length3]
 629                     compresseddata = zlib.compress(uncompresseddata)
 630
 631                     file.write("%d 0 obj\n"
 632                                "<<\n"
 633                                "/Length %d\n"
 634                                "/Length1 %d\n"
 635                                "/Length2 %d\n"
 636                                "/Length3 %d\n"
 637                                "/Filter /FlateDecode\n"
 638                                ">>\n"
 639                                "stream\n" % (fontnr+fontstartref, len(compresseddata),
 640                                                                   length1,
 641                                                                   length2,
 642                                                                   length3))
 643                     #file.write(fontdata[6:6+length1])
 644                     #file.write(fontdata[12+length1:12+length1+length2])
 645                     #file.write(fontdata[18+length1+length2:18+length1+length2+length3])
 646                     file.write(compresseddata)
 647                     file.write("endstream\n"
 648                                "endobj\n")
 649                 else:
 650                     fontnr += 2
 651
 652         xrefpos = file.tell()
 653         file.write("xref\n"
 654                    "0 %d\n" % (len(reflist)+1))
 655         file.write("0000000000 65535 f \n")
 656         for ref in reflist:
 657             file.write("%010i 00000 n \n" % ref)
 658         file.write("trailer\n"
 659                    "<<\n"
 660                    "/Size 8\n"
 661                    "/Root 1 0 R\n"
 662                    ">>\n"
 663                    "startxref\n"
 664                    "%i\n"
 665                    "%%%%EOF\n" % xrefpos)
 666
 667     def writetofile(self, filename, *args, **kwargs):
 668         if filename[-4:] == ".eps":
 669             self.writeEPSfile(filename, *args, **kwargs)
 670         elif filename[-4:] == ".pdf":
 671             self.writePDFfile(filename, *args, **kwargs)
 672         else:
 673             sys.stderr.write("*** PyX Warning: deprecated usage of writetofile -- writetofile needs a filename extension or use an explicit call to writeEPSfile or the like\n")
 674             self.writeEPSfile(filename, *args, **kwargs)
 675
 676 class page(canvas):
 677
 678     def __init__(self, attrs=[], texrunner=None, pagename=None, paperformat="a4", rotated=0, fittosize=0,
 679                  margin=1 * unit.t_cm, bboxenlarge=1 * unit.t_pt):
 680         canvas.__init__(self, attrs, texrunner)
 681         self.pagename = pagename
 682         self.paperformat = paperformat.capitalize()
 683         self.rotated = rotated
 684         self.fittosize = fittosize
 685         self.margin = margin
 686         self.bboxenlarge = bboxenlarge
 687
 688     def bbox(self):
 689         # the bounding box of a page is fixed by its format and an optional rotation
 690         pbbox = bbox.bbox(0, 0, *_paperformats[self.paperformat])
 691         pbbox.enlarge(self.bboxenlarge)
 692         if self.rotated:
 693             pbbox.transform(trafo.rotate(90, *pbbox.center()))
 694         return pbbox
 695
 696     def outputPS(self, file):
 697         file.write("%%%%PageMedia: %s\n" % self.paperformat)
 698         file.write("%%%%PageOrientation: %s\n" % (self.rotated and "Landscape" or "Portrait"))
 699         # file.write("%%%%PageBoundingBox: %d %d %d %d\n" % (math.floor(pbbox.llx_pt), math.floor(pbbox.lly_pt),
 700         #                                                    math.ceil(pbbox.urx_pt), math.ceil(pbbox.ury_pt)))
 701
 702         # page setup section
 703         file.write("%%BeginPageSetup\n")
 704         file.write("/pgsave save def\n")
 705         # for scaling, we need the real bounding box of the page contents
 706         pbbox = canvas.bbox(self)
 707         pbbox.enlarge(self.bboxenlarge)
 708         ptrafo = calctrafo(pbbox, self.paperformat, self.margin, self.rotated, self.fittosize)
 709         if ptrafo:
 710             ptrafo.outputPS(file)
 711         file.write("%f setlinewidth\n" % unit.topt(style.linewidth.normal))
 712         file.write("%%EndPageSetup\n")
 713
 714         # here comes the actual content
 715         canvas.outputPS(self, file)
 716         file.write("pgsave restore\n")
 717         file.write("showpage\n")
 718         # file.write("%%PageTrailer\n")
 719
 720
 721 class document:
 722
 723     """holds a collection of page instances which are output as pages of a document"""
 724
 725     def __init__(self, pages=[]):
 726         self.pages = pages
 727
 728     def append(self, page):
 729         self.pages.append(page)
 730
 731     def writePSfile(self, filename):
 732         """write pages to PS file """
 733
 734         if filename[-3:]!=".ps":
 735             filename = filename + ".ps"
 736
 737         try:
 738             file = open(filename, "w")
 739         except IOError:
 740             raise IOError("cannot open output file")
 741
 742         docbbox = None
 743         for apage in self.pages:
 744             pbbox = apage.bbox()
 745             if docbbox is None:
 746                 docbbox = pbbox
 747             else:
 748                 docbbox += pbbox
 749
 750         # document header
 751         file.write("%!PS-Adobe-3.0\n")
 752         docbbox.outputPS(file)
 753         file.write("%%%%Creator: PyX %s\n" % version.version)
 754         file.write("%%%%Title: %s\n" % filename)
 755         file.write("%%%%CreationDate: %s\n" %
 756                    time.asctime(time.localtime(time.time())))
 757         # required paper formats
 758         paperformats = {}
 759         for apage in self.pages:
 760             if isinstance(apage, page):
 761                 paperformats[apage.paperformat] = _paperformats[apage.paperformat]
 762         first = 1
 763         for paperformat, size in paperformats.items():
 764             if first:
 765                 file.write("%%DocumentMedia: ")
 766                 first = 0
 767             else:
 768                 file.write("%%+ ")
 769             file.write("%s %d %d 75 white ()\n" % (paperformat, unit.topt(size[0]), unit.topt(size[1])))
 770
 771         file.write("%%%%Pages: %d\n" % len(self.pages))
 772         file.write("%%PageOrder: Ascend\n")
 773         file.write("%%EndComments\n")
 774
 775         # document default section
 776         #file.write("%%BeginDefaults\n")
 777         #if paperformat:
 778         #    file.write("%%%%PageMedia: %s\n" % paperformat)
 779         #file.write("%%%%PageOrientation: %s\n" % (rotated and "Landscape" or "Portrait"))
 780         #file.write("%%EndDefaults\n")
 781
 782         # document prolog section
 783         file.write("%%BeginProlog\n")
 784         mergedprolog = []
 785         for apage in self.pages:
 786             for pritem in apage.prolog():
 787                 for mpritem in mergedprolog:
 788                     if mpritem.merge(pritem) is None: break
 789                 else:
 790                     mergedprolog.append(pritem)
 791         for pritem in mergedprolog:
 792             pritem.outputPS(file)
 793         file.write("%%EndProlog\n")
 794
 795         # document setup section
 796         #file.write("%%BeginSetup\n")
 797         #file.write("%%EndSetup\n")
 798
 799         # pages section
 800         for nr, apage in enumerate(self.pages):
 801             file.write("%%%%Page: %s %d\n" % (apage.pagename is None and str(nr) or apage.pagename , nr+1))
 802             apage.outputPS(file)
 803
 804         file.write("%%Trailer\n")
 805         file.write("%%EOF\n")