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(self.xstep)
 314         if self.ystep is None:
 315             ystep = unit.topt(realpatternbbox.height())
 316         else:
 317            ystep = unit.topt(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     if not isinstance(margin, unit.length):
 352         margin = unit.length(margin)
 353     atrafo = None     # global transformation of canvas
 354
 355     if rotated:
 356         atrafo = trafo.rotate(90, *abbox.center())
 357
 358     if paperformat:
 359         # center (optionally rotated) output on page
 360         try:
 361             paperwidth, paperheight = _paperformats[paperformat.capitalize()]
 362         except KeyError:
 363             raise KeyError, "unknown paperformat '%s'" % paperformat
 364
 365         paperwidth -= 2*margin
 366         paperheight -= 2*margin
 367
 368         if not atrafo: atrafo = trafo.trafo()
 369
 370         atrafo = atrafo.translated(margin + 0.5*(paperwidth  - abbox.width())  - abbox.left(),
 371                                    margin + 0.5*(paperheight - abbox.height()) - abbox.bottom())
 372
 373         if fittosize:
 374             # scale output to pagesize - margins
 375             if 2*margin > min(paperwidth, paperheight):
 376                 raise RuntimeError("Margins too broad for selected paperformat. Aborting.")
 377
 378             if rotated:
 379                 sfactor = min(unit.topt(paperheight)/unit.topt(abbox.width()),
 380                               unit.topt(paperwidth)/unit.topt(abbox.height()))
 381             else:
 382                 sfactor = min(unit.topt(paperwidth)/unit.topt(abbox.width()),
 383                               unit.topt(paperheight)/unit.topt(abbox.height()))
 384
 385             atrafo = atrafo.scaled(sfactor, sfactor, margin + 0.5*paperwidth, margin + 0.5*paperheight)
 386     elif fittosize:
 387         raise ValueError("must specify paper size for fittosize")
 388
 389     return atrafo
 390
 391 #
 392 # The main canvas class
 393 #
 394
 395 class canvas(_canvas):
 396
 397     """a canvas is a collection of PSCmds together with PSAttrs"""
 398
 399     def writeEPSfile(self, filename, paperformat=None, rotated=0, fittosize=0, margin=1 * unit.t_cm,
 400                     bbox=None, bboxenlarge=1 * unit.t_pt):
 401         """write canvas to EPS file
 402
 403         If paperformat is set to a known paperformat, the output will be centered on
 404         the page.
 405
 406         If rotated is set, the output will first be rotated by 90 degrees.
 407
 408         If fittosize is set, then the output is scaled to the size of the
 409         page (minus margin). In that case, the paperformat the specification
 410         of the paperformat is obligatory.
 411
 412         The bbox parameter overrides the automatic bounding box determination.
 413         bboxenlarge may be used to enlarge the bbox of the canvas (or the
 414         manually specified bbox).
 415         """
 416
 417         if filename[-4:]!=".eps":
 418             filename = filename + ".eps"
 419
 420         try:
 421             file = open(filename, "w")
 422         except IOError:
 423             raise IOError("cannot open output file")
 424
 425         abbox = bbox is not None and bbox or self.bbox()
 426         abbox.enlarge(bboxenlarge)
 427         ctrafo = calctrafo(abbox, paperformat, margin, rotated, fittosize)
 428
 429         # if there has been a global transformation, adjust the bounding box
 430         # accordingly
 431         if ctrafo: abbox.transform(ctrafo)
 432
 433         file.write("%!PS-Adobe-3.0 EPSF 3.0\n")
 434         abbox.outputPS(file)
 435         file.write("%%%%Creator: PyX %s\n" % version.version)
 436         file.write("%%%%Title: %s\n" % filename)
 437         file.write("%%%%CreationDate: %s\n" %
 438                    time.asctime(time.localtime(time.time())))
 439         file.write("%%EndComments\n")
 440
 441         file.write("%%BeginProlog\n")
 442
 443         mergedprolog = []
 444
 445         for pritem in self.prolog():
 446             for mpritem in mergedprolog:
 447                 if mpritem.merge(pritem) is None: break
 448             else:
 449                 mergedprolog.append(pritem)
 450
 451         for pritem in mergedprolog:
 452             pritem.outputPS(file)
 453
 454         file.write("%%EndProlog\n")
 455
 456         # apply a possible global transformation
 457         if ctrafo: ctrafo.outputPS(file)
 458
 459         file.write("%f setlinewidth\n" % unit.topt(style.linewidth.normal))
 460
 461         # here comes the actual content
 462         self.outputPS(file)
 463
 464         file.write("showpage\n")
 465         file.write("%%Trailer\n")
 466         file.write("%%EOF\n")
 467
 468     def writePDFfile(self, filename, paperformat=None, rotated=0, fittosize=0, margin=1 * unit.t_cm,
 469                     bbox=None, bboxenlarge=1 * unit.t_pt):
 470         sys.stderr.write("*** PyX Warning: writePDFfile is experimental and supports only a subset of PyX's features\n")
 471
 472         if filename[-4:]!=".pdf":
 473             filename = filename + ".pdf"
 474
 475         try:
 476             file = open(filename, "wb")
 477         except IOError:
 478             raise IOError("cannot open output file")
 479
 480         abbox = bbox is not None and bbox or self.bbox()
 481         abbox.enlarge(bboxenlarge)
 482
 483         ctrafo = calctrafo(abbox, paperformat, margin, rotated, fittosize)
 484
 485         # if there has been a global transformation, adjust the bounding box
 486         # accordingly
 487         if ctrafo: abbox.transform(ctrafo)
 488
 489         mergedprolog = []
 490
 491         for pritem in self.prolog():
 492             for mpritem in mergedprolog:
 493                 if mpritem.merge(pritem) is None: break
 494             else:
 495                 mergedprolog.append(pritem)
 496
 497         file.write("%%PDF-1.4\n%%%s%s%s%s\n" % (chr(195), chr(182), chr(195), chr(169)))
 498         reflist = [file.tell()]
 499         file.write("1 0 obj\n"
 500                    "<<\n"
 501                    "/Type /Catalog\n"
 502                    "/Pages 2 0 R\n"
 503                    ">>\n"
 504                    "endobj\n")
 505         reflist.append(file.tell())
 506         file.write("2 0 obj\n"
 507                    "<<\n"
 508                    "/Type /Pages\n"
 509                    "/Kids [3 0 R]\n"
 510                    "/Count 1\n"
 511                    ">>\n"
 512                    "endobj\n")
 513         reflist.append(file.tell())
 514         file.write("3 0 obj\n"
 515                    "<<\n"
 516                    "/Type /Page\n"
 517                    "/Parent 2 0 R\n")
 518         abbox.outputPDF(file)
 519         file.write("/Contents 4 0 R\n"
 520                    "/Resources <<\n")
 521         fontstartref = 5
 522
 523         fontnr = 0
 524         if len([pritem for pritem in mergedprolog if isinstance(pritem, prolog.fontdefinition)]):
 525             file.write("/Font\n"
 526                        "<<\n")
 527             for pritem in mergedprolog:
 528                 if isinstance(pritem, prolog.fontdefinition):
 529                     fontnr += 1
 530                     file.write("/%s %d 0 R\n" % (pritem.font.getpsname(), fontnr+fontstartref))
 531                     fontnr += 3 # further objects due to a font
 532             file.write(">>\n")
 533
 534         file.write(">>\n"
 535                    ">>\n"
 536                    "endobj\n")
 537         reflist.append(file.tell())
 538         file.write("4 0 obj\n"
 539                    "<< /Length 5 0 R >>\n"
 540                    "stream\n")
 541         streamstartpos = file.tell()
 542
 543         # apply a possible global transformation
 544         if ctrafo: ctrafo.outputPDF(file)
 545         style.linewidth.normal.outputPDF(file)
 546
 547         self.outputPDF(file)
 548         streamendpos = file.tell()
 549         file.write("endstream\n"
 550                    "endobj\n")
 551         reflist.append(file.tell())
 552         file.write("5 0 obj\n"
 553                    "%s\n"
 554                    "endobj\n" % (streamendpos - streamstartpos))
 555
 556         fontnr = 0
 557         for pritem in mergedprolog:
 558             if isinstance(pritem, prolog.fontdefinition):
 559                 fontnr += 1
 560                 reflist.append(file.tell())
 561                 file.write("%d 0 obj\n"
 562                            "<<\n"
 563                            "/Type /Font\n"
 564                            "/Subtype /Type1\n"
 565                            "/Name /%s\n"
 566                            "/BaseFont /%s\n"
 567                            "/FirstChar 0\n"
 568                            "/LastChar 255\n"
 569                            "/Widths %d 0 R\n"
 570                            "/FontDescriptor %d 0 R\n"
 571                            "/Encoding /StandardEncoding\n" # FIXME
 572                            ">>\n"
 573                            "endobj\n" % (fontnr+fontstartref, pritem.font.getpsname(), pritem.font.getbasepsname(),
 574                                          fontnr+fontstartref+1, fontnr+fontstartref+2))
 575                 fontnr += 1
 576                 reflist.append(file.tell())
 577                 file.write("%d 0 obj\n"
 578                            "[\n" % (fontnr+fontstartref))
 579                 for i in range(256):
 580                     try:
 581                         width = pritem.font.getwidth_pt(i)*1000/pritem.font.getsize_pt()
 582                     except:
 583                         width = 0
 584                     file.write("%f\n" % width)
 585                 file.write("]\n"
 586                            "endobj\n")
 587                 if pritem.filename:
 588                     fontnr += 1
 589                     reflist.append(file.tell())
 590                     file.write("%d 0 obj\n"
 591                                "<<\n"
 592                                "/Type /FontDescriptor\n"
 593                                "/FontName /%s\n"
 594                                "/Flags 4\n" # FIXME
 595                                "/FontBBox [-10 -10 1000 1000]\n" # FIXME
 596                                "/ItalicAngle 0\n" # FIXME
 597                                "/Ascent 20\n" # FIXME
 598                                "/Descent -5\n" # FIXME
 599                                "/CapHeight 15\n" # FIXME
 600                                "/StemV 3\n" # FIXME
 601                                "/FontFile %d 0 R\n" # FIXME
 602                                # "/CharSet \n" # fill in when stripping
 603                                ">>\n"
 604                                "endobj\n" % (fontnr+fontstartref, pritem.font.getbasepsname(),
 605                                              fontnr+fontstartref+1))
 606
 607                     fontnr += 1
 608                     reflist.append(file.tell())
 609
 610                     fontdata = open(pykpathsea.find_file(pritem.filename, pykpathsea.kpse_type1_format)).read()
 611                     if fontdata[0:2] != fullfont._PFB_ASCII:
 612                         raise RuntimeError("PFB_ASCII mark expected")
 613                     length1 = fullfont.pfblength(fontdata[2:6])
 614                     if fontdata[6+length1:8+length1] != fullfont._PFB_BIN:
 615                         raise RuntimeError("PFB_BIN mark expected")
 616                     length2 = fullfont.pfblength(fontdata[8+length1:12+length1])
 617                     if fontdata[12+length1+length2:14+length1+length2] != fullfont._PFB_ASCII:
 618                         raise RuntimeError("PFB_ASCII mark expected")
 619                     length3 = fullfont.pfblength(fontdata[14+length1+length2:18+length1+length2])
 620                     if fontdata[18+length1+length2+length3:20+length1+length2+length3] != fullfont._PFB_DONE:
 621                         raise RuntimeError("PFB_DONE mark expected")
 622                     if len(fontdata) != 20 + length1 + length2 + length3:
 623                         raise RuntimeError("end of pfb file expected")
 624
 625                     # we might be allowed to skip the third part ...
 626                     if fontdata[18+length1+length2:18+length1+length2+length3].replace("\n", "").replace("\r", "").replace("\t", "").replace(" ", "") == "0"*512 + "cleartomark":
 627                         length3 = 0
 628
 629                     uncompresseddata = fontdata[6:6+length1] + fontdata[12+length1:12+length1+length2] + fontdata[18+length1+length2:18+length1+length2+length3]
 630                     compresseddata = zlib.compress(uncompresseddata)
 631
 632                     file.write("%d 0 obj\n"
 633                                "<<\n"
 634                                "/Length %d\n"
 635                                "/Length1 %d\n"
 636                                "/Length2 %d\n"
 637                                "/Length3 %d\n"
 638                                "/Filter /FlateDecode\n"
 639                                ">>\n"
 640                                "stream\n" % (fontnr+fontstartref, len(compresseddata),
 641                                                                   length1,
 642                                                                   length2,
 643                                                                   length3))
 644                     #file.write(fontdata[6:6+length1])
 645                     #file.write(fontdata[12+length1:12+length1+length2])
 646                     #file.write(fontdata[18+length1+length2:18+length1+length2+length3])
 647                     file.write(compresseddata)
 648                     file.write("endstream\n"
 649                                "endobj\n")
 650                 else:
 651                     fontnr += 2
 652
 653         xrefpos = file.tell()
 654         file.write("xref\n"
 655                    "0 %d\n" % (len(reflist)+1))
 656         file.write("0000000000 65535 f \n")
 657         for ref in reflist:
 658             file.write("%010i 00000 n \n" % ref)
 659         file.write("trailer\n"
 660                    "<<\n"
 661                    "/Size 8\n"
 662                    "/Root 1 0 R\n"
 663                    ">>\n"
 664                    "startxref\n"
 665                    "%i\n"
 666                    "%%%%EOF\n" % xrefpos)
 667
 668     def writetofile(self, filename, *args, **kwargs):
 669         if filename[-4:] == ".eps":
 670             self.writeEPSfile(filename, *args, **kwargs)
 671         elif filename[-4:] == ".pdf":
 672             self.writePDFfile(filename, *args, **kwargs)
 673         else:
 674             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")
 675             self.writeEPSfile(filename, *args, **kwargs)
 676
 677 class page(canvas):
 678
 679     def __init__(self, attrs=[], texrunner=None, pagename=None, paperformat="a4", rotated=0, fittosize=0,
 680                  margin=1 * unit.t_cm, bboxenlarge=1 * unit.t_pt):
 681         canvas.__init__(self, attrs, texrunner)
 682         self.pagename = pagename
 683         self.paperformat = paperformat.capitalize()
 684         self.rotated = rotated
 685         self.fittosize = fittosize
 686         self.margin = margin
 687         self.bboxenlarge = bboxenlarge
 688
 689     def bbox(self):
 690         # the bounding box of a page is fixed by its format and an optional rotation
 691         pbbox = bbox.bbox(0, 0, *_paperformats[self.paperformat])
 692         pbbox.enlarge(self.bboxenlarge)
 693         if self.rotated:
 694             pbbox.transform(trafo.rotate(90, *pbbox.center()))
 695         return pbbox
 696
 697     def outputPS(self, file):
 698         file.write("%%%%PageMedia: %s\n" % self.paperformat)
 699         file.write("%%%%PageOrientation: %s\n" % (self.rotated and "Landscape" or "Portrait"))
 700         # file.write("%%%%PageBoundingBox: %d %d %d %d\n" % (math.floor(pbbox.llx_pt), math.floor(pbbox.lly_pt),
 701         #                                                    math.ceil(pbbox.urx_pt), math.ceil(pbbox.ury_pt)))
 702
 703         # page setup section
 704         file.write("%%BeginPageSetup\n")
 705         file.write("/pgsave save def\n")
 706         # for scaling, we need the real bounding box of the page contents
 707         pbbox = canvas.bbox(self)
 708         pbbox.enlarge(self.bboxenlarge)
 709         ptrafo = calctrafo(pbbox, self.paperformat, self.margin, self.rotated, self.fittosize)
 710         if ptrafo:
 711             ptrafo.outputPS(file)
 712         file.write("%f setlinewidth\n" % unit.topt(style.linewidth.normal))
 713         file.write("%%EndPageSetup\n")
 714
 715         # here comes the actual content
 716         canvas.outputPS(self, file)
 717         file.write("pgsave restore\n")
 718         file.write("showpage\n")
 719         # file.write("%%PageTrailer\n")
 720
 721
 722 class document:
 723
 724     """holds a collection of page instances which are output as pages of a document"""
 725
 726     def __init__(self, pages=[]):
 727         self.pages = pages
 728
 729     def append(self, page):
 730         self.pages.append(page)
 731
 732     def writePSfile(self, filename):
 733         """write pages to PS file """
 734
 735         if filename[-3:]!=".ps":
 736             filename = filename + ".ps"
 737
 738         try:
 739             file = open(filename, "w")
 740         except IOError:
 741             raise IOError("cannot open output file")
 742
 743         docbbox = None
 744         for apage in self.pages:
 745             pbbox = apage.bbox()
 746             if docbbox is None:
 747                 docbbox = pbbox
 748             else:
 749                 docbbox += pbbox
 750
 751         # document header
 752         file.write("%!PS-Adobe-3.0\n")
 753         docbbox.outputPS(file)
 754         file.write("%%%%Creator: PyX %s\n" % version.version)
 755         file.write("%%%%Title: %s\n" % filename)
 756         file.write("%%%%CreationDate: %s\n" %
 757                    time.asctime(time.localtime(time.time())))
 758         # required paper formats
 759         paperformats = {}
 760         for apage in self.pages:
 761             if isinstance(apage, page):
 762                 paperformats[apage.paperformat] = _paperformats[apage.paperformat]
 763         first = 1
 764         for paperformat, size in paperformats.items():
 765             if first:
 766                 file.write("%%DocumentMedia: ")
 767                 first = 0
 768             else:
 769                 file.write("%%+ ")
 770             file.write("%s %d %d 75 white ()\n" % (paperformat, unit.topt(size[0]), unit.topt(size[1])))
 771
 772         file.write("%%%%Pages: %d\n" % len(self.pages))
 773         file.write("%%PageOrder: Ascend\n")
 774         file.write("%%EndComments\n")
 775
 776         # document default section
 777         #file.write("%%BeginDefaults\n")
 778         #if paperformat:
 779         #    file.write("%%%%PageMedia: %s\n" % paperformat)
 780         #file.write("%%%%PageOrientation: %s\n" % (rotated and "Landscape" or "Portrait"))
 781         #file.write("%%EndDefaults\n")
 782
 783         # document prolog section
 784         file.write("%%BeginProlog\n")
 785         mergedprolog = []
 786         for apage in self.pages:
 787             for pritem in apage.prolog():
 788                 for mpritem in mergedprolog:
 789                     if mpritem.merge(pritem) is None: break
 790                 else:
 791                     mergedprolog.append(pritem)
 792         for pritem in mergedprolog:
 793             pritem.outputPS(file)
 794         file.write("%%EndProlog\n")
 795
 796         # document setup section
 797         #file.write("%%BeginSetup\n")
 798         #file.write("%%EndSetup\n")
 799
 800         # pages section
 801         for nr, apage in enumerate(self.pages):
 802             file.write("%%%%Page: %s %d\n" % (apage.pagename is None and str(nr) or apage.pagename , nr+1))
 803             apage.outputPS(file)
 804
 805         file.write("%%Trailer\n")
 806         file.write("%%EOF\n")