pyx/pdfwriter.py

   1 #!/usr/bin/env python
   2 # -*- coding: ISO-8859-1 -*-
   3 #
   4 #
   5 # Copyright (C) 2005-2006 Jörg Lehmann <joergl@users.sourceforge.net>
   6 # Copyright (C) 2005-2006 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
  23
  24 import cStringIO, copy, warnings, time
  25 try:
  26     import zlib
  27     haszlib = 1
  28 except:
  29     haszlib = 0
  30
  31 import bbox, unit, style, type1font, version
  32
  33 try:
  34     enumerate([])
  35 except NameError:
  36     # fallback implementation for Python 2.2 and below
  37     def enumerate(list):
  38         return zip(xrange(len(list)), list)
  39
  40 try:
  41     dict([])
  42 except NameError:
  43     # fallback implementation for Python 2.1
  44     def dict(list):
  45         result = {}
  46         for key, value in list:
  47             result[key] = value
  48         return result
  49
  50
  51 class PDFregistry:
  52
  53     def __init__(self):
  54         self.types = {}
  55         # we want to keep the order of the resources
  56         self.objects = []
  57         self.resources = {}
  58         self.procsets = {"PDF": 1}
  59         self.merged = None
  60
  61     def add(self, object):
  62         """ register object, merging it with an already registered object of the same type and id """
  63         sameobjects = self.types.setdefault(object.type, {})
  64         if sameobjects.has_key(object.id):
  65             sameobjects[object.id].merge(object)
  66         else:
  67             self.objects.append(object)
  68             sameobjects[object.id] = object
  69
  70     def getrefno(self, object):
  71         if self.merged:
  72             return self.merged.getrefno(object)
  73         else:
  74             return self.types[object.type][object.id].refno
  75
  76     def mergeregistry(self, registry):
  77         for object in registry.objects:
  78             self.add(object)
  79         registry.merged = self
  80
  81     def write(self, file, writer, catalog):
  82         # first we set all refnos
  83         refno = 1
  84         for object in self.objects:
  85             object.refno = refno
  86             refno += 1
  87
  88         # second, all objects are written, keeping the positions in the output file
  89         fileposes = []
  90         for object in self.objects:
  91             fileposes.append(file.tell())
  92             file.write("%i 0 obj\n" % object.refno)
  93             object.write(file, writer, self)
  94             file.write("endobj\n")
  95
  96         # xref
  97         xrefpos = file.tell()
  98         file.write("xref\n"
  99                    "0 %d\n"
 100                    "0000000000 65535 f \n" % refno)
 101
 102         for filepos in fileposes:
 103             file.write("%010i 00000 n \n" % filepos)
 104
 105         # trailer
 106         file.write("trailer\n"
 107                    "<<\n"
 108                    "/Size %i\n" % refno)
 109         file.write("/Root %i 0 R\n" % self.getrefno(catalog))
 110         file.write("/Info %i 0 R\n" % self.getrefno(catalog.PDFinfo))
 111         file.write(">>\n"
 112                    "startxref\n"
 113                    "%i\n" % xrefpos)
 114         file.write("%%EOF\n")
 115
 116     def addresource(self, resourcetype, resourcename, object, procset=None):
 117         self.resources.setdefault(resourcetype, {})[resourcename] = object
 118         if procset:
 119             self.procsets[procset] = 1
 120
 121     def writeresources(self, file):
 122         file.write("/Resources <<\n")
 123         file.write("/ProcSet [ %s ]\n" % " ".join(["/%s" % p for p in self.procsets.keys()]))
 124         if self.resources:
 125             for resourcetype, resources in self.resources.items():
 126                 file.write("/%s <<\n%s\n>>\n" % (resourcetype, "\n".join(["/%s %i 0 R" % (name, self.getrefno(object))
 127                                                                           for name, object in resources.items()])))
 128         file.write(">>\n")
 129
 130
 131 class PDFobject:
 132
 133     def __init__(self, type, _id=None):
 134         """create a PDFobject
 135           - type has to be a string describing the type of the object
 136           - _id is a unique identification used for the object if it is not None.
 137             Otherwise id(self) is used
 138         """
 139         self.type = type
 140         if _id is None:
 141             self.id = id(self)
 142         else:
 143             self.id = _id
 144
 145     def merge(self, other):
 146         pass
 147
 148     def write(self, file, writer, registry):
 149         raise NotImplementedError("write method has to be provided by PDFobject subclass")
 150
 151
 152 class PDFcatalog(PDFobject):
 153
 154     def __init__(self, document, writer, registry):
 155         PDFobject.__init__(self, "catalog")
 156         self.PDFpages = PDFpages(document, writer, registry)
 157         registry.add(self.PDFpages)
 158         self.PDFinfo = PDFinfo()
 159         registry.add(self.PDFinfo)
 160
 161     def write(self, file, writer, registry):
 162         file.write("<<\n"
 163                    "/Type /Catalog\n"
 164                    "/Pages %i 0 R\n" % registry.getrefno(self.PDFpages))
 165         if writer.fullscreen:
 166             file.write("/PageMode /FullScreen\n")
 167         file.write(">>\n")
 168
 169
 170 class PDFinfo(PDFobject):
 171
 172     def __init__(self):
 173         PDFobject.__init__(self, "info")
 174
 175     def write(self, file, writer, registry):
 176         if time.timezone < 0:
 177             # divmod on positive numbers, otherwise the minutes have a different sign from the hours
 178             timezone = "-%02i'%02i'" % divmod(-time.timezone/60, 60)
 179         elif time.timezone > 0:
 180             timezone = "+%02i'%02i'" % divmod(time.timezone/60, 60)
 181         else:
 182             timezone = "Z00'00'"
 183
 184         def pdfstring(s):
 185             r = ""
 186             for c in s:
 187                 if 32 <= ord(c) <= 127 and c not in "()[]<>\\":
 188                     r += c
 189                 else:
 190                     r += "\\%03o" % ord(c)
 191             return r
 192
 193         file.write("<<\n")
 194         if writer.title:
 195             file.write("/Title (%s)\n" % pdfstring(writer.title))
 196         if writer.author:
 197             file.write("/Author (%s)\n" % pdfstring(writer.author))
 198         if writer.subject:
 199             file.write("/Subject (%s)\n" % pdfstring(writer.subject))
 200         if writer.keywords:
 201             file.write("/Keywords (%s)\n" % pdfstring(writer.keywords))
 202         file.write("/Creator (PyX %s)\n" % version.version)
 203         file.write("/CreationDate (D:%s%s)\n" % (time.strftime("%Y%m%d%H%M"), timezone))
 204         file.write(">>\n")
 205
 206
 207 class PDFpages(PDFobject):
 208
 209     def __init__(self, document, writer, registry):
 210         PDFobject.__init__(self, "pages")
 211         self.PDFpagelist = []
 212         for pageno, page in enumerate(document.pages):
 213             page = PDFpage(page, pageno, self, writer, registry)
 214             registry.add(page)
 215             self.PDFpagelist.append(page)
 216
 217     def write(self, file, writer, registry):
 218         file.write("<<\n"
 219                    "/Type /Pages\n"
 220                    "/Kids [%s]\n"
 221                    "/Count %i\n"
 222                    ">>\n" % (" ".join(["%i 0 R" % registry.getrefno(page)
 223                                        for page in self.PDFpagelist]),
 224                              len(self.PDFpagelist)))
 225
 226
 227 class PDFpage(PDFobject):
 228
 229     def __init__(self, page, pageno, PDFpages, writer, registry):
 230         PDFobject.__init__(self, "page")
 231         self.PDFpages = PDFpages
 232         self.page = page
 233
 234         # every page uses its own registry in order to find out which
 235         # resources are used within the page. However, the
 236         # pageregistry is also merged in the global registry
 237         self.pageregistry = PDFregistry()
 238
 239         self.PDFcontent = PDFcontent(page, writer, self.pageregistry)
 240         self.pageregistry.add(self.PDFcontent)
 241         registry.mergeregistry(self.pageregistry)
 242
 243     def write(self, file, writer, registry):
 244         file.write("<<\n"
 245                    "/Type /Page\n"
 246                    "/Parent %i 0 R\n" % registry.getrefno(self.PDFpages))
 247         paperformat = self.page.paperformat
 248         if paperformat:
 249             file.write("/MediaBox [0 0 %f %f]\n" % (unit.topt(paperformat.width), unit.topt(paperformat.height)))
 250         else:
 251             file.write("/MediaBox [%f %f %f %f]\n" % self.PDFcontent.bbox.highrestuple_pt())
 252         if self.PDFcontent.bbox and writer.writebbox:
 253             file.write("/CropBox [%f %f %f %f]\n" % self.PDFcontent.bbox.highrestuple_pt())
 254         if self.page.rotated:
 255             file.write("/Rotate 90\n")
 256         file.write("/Contents %i 0 R\n" % registry.getrefno(self.PDFcontent))
 257         self.pageregistry.writeresources(file)
 258         file.write(">>\n")
 259
 260
 261 class PDFcontent(PDFobject):
 262
 263     def __init__(self, page, writer, registry):
 264         PDFobject.__init__(self, registry, "content")
 265         contentfile = cStringIO.StringIO()
 266         self.bbox = bbox.empty()
 267         acontext = context()
 268         page.processPDF(contentfile, writer, acontext, registry, self.bbox)
 269         self.content = contentfile.getvalue()
 270         contentfile.close()
 271
 272     def write(self, file, writer, registry):
 273         if writer.compress:
 274             content = zlib.compress(self.content)
 275         else:
 276             content = self.content
 277         file.write("<<\n"
 278                    "/Length %i\n" % len(content))
 279         if writer.compress:
 280             file.write("/Filter /FlateDecode\n")
 281         file.write(">>\n"
 282                    "stream\n")
 283         file.write(content)
 284         file.write("endstream\n")
 285
 286
 287 class PDFfont(PDFobject):
 288
 289     def __init__(self, font, chars, writer, registry):
 290         PDFobject.__init__(self, "font", font.name)
 291         registry.addresource("Font", font.name, self, procset="Text")
 292
 293         self.fontdescriptor = PDFfontdescriptor(font, chars, writer, registry)
 294         registry.add(self.fontdescriptor)
 295
 296         if font.encoding:
 297             self.encoding = PDFencoding(font.encoding, writer, registry)
 298             registry.add(self.encoding)
 299         else:
 300             self.encoding = None
 301
 302         self.name = font.name
 303         self.basefontname = font.basefontname
 304         self.metric = font.metric
 305
 306     def write(self, file, writer, registry):
 307         file.write("<<\n"
 308                    "/Type /Font\n"
 309                    "/Subtype /Type1\n")
 310         file.write("/Name /%s\n" % self.name)
 311         file.write("/BaseFont /%s\n" % self.basefontname)
 312         if self.fontdescriptor.fontfile is not None and self.fontdescriptor.fontfile.usedchars is not None:
 313             usedchars = self.fontdescriptor.fontfile.usedchars
 314             firstchar = min(usedchars.keys())
 315             lastchar = max(usedchars.keys())
 316             file.write("/FirstChar %d\n" % firstchar)
 317             file.write("/LastChar %d\n" % lastchar)
 318             file.write("/Widths\n"
 319                        "[")
 320             for i in range(firstchar, lastchar+1):
 321                 if i and not (i % 8):
 322                     file.write("\n")
 323                 else:
 324                     file.write(" ")
 325                 if usedchars.has_key(i):
 326                     file.write("%f" % self.metric.getwidth_ds(i))
 327                 else:
 328                     file.write("0")
 329             file.write(" ]\n")
 330         else:
 331             file.write("/FirstChar 0\n"
 332                        "/LastChar 255\n"
 333                        "/Widths\n"
 334                        "[")
 335             for i in range(256):
 336                 if i and not (i % 8):
 337                     file.write("\n")
 338                 else:
 339                     file.write(" ")
 340                 try:
 341                     width = self.metric.getwidth_ds(i)
 342                 except (IndexError, AttributeError):
 343                     width = 0
 344                 file.write("%f" % width)
 345             file.write(" ]\n")
 346         file.write("/FontDescriptor %d 0 R\n" % registry.getrefno(self.fontdescriptor))
 347         if self.encoding:
 348             file.write("/Encoding %d 0 R\n" % registry.getrefno(self.encoding))
 349         file.write(">>\n")
 350
 351
 352 class PDFfontdescriptor(PDFobject):
 353
 354     def __init__(self, font, chars, writer, registry):
 355         PDFobject.__init__(self, "fontdescriptor", font.basefontname)
 356
 357         if font.filename is None:
 358             self.fontfile = None
 359         else:
 360             self.fontfile = PDFfontfile(font.basefontname, font.filename, font.encoding, chars, writer, registry)
 361             registry.add(self.fontfile)
 362
 363         self.name = font.basefontname
 364         self.fontinfo = font.metric.fontinfo()
 365
 366     def write(self, file, writer, registry):
 367         file.write("<<\n"
 368                    "/Type /FontDescriptor\n"
 369                    "/FontName /%s\n" % self.name)
 370         if self.fontfile is None:
 371             file.write("/Flags 32\n")
 372         else:
 373             file.write("/Flags %d\n" % self.fontfile.getflags())
 374         file.write("/FontBBox [%d %d %d %d]\n" % self.fontinfo.fontbbox)
 375         file.write("/ItalicAngle %d\n" % self.fontinfo.italicangle)
 376         file.write("/Ascent %d\n" % self.fontinfo.ascent)
 377         file.write("/Descent %d\n" % self.fontinfo.descent)
 378         file.write("/CapHeight %d\n" % self.fontinfo.capheight)
 379         file.write("/StemV %d\n" % self.fontinfo.vstem)
 380         if self.fontfile is not None:
 381             file.write("/FontFile %d 0 R\n" % registry.getrefno(self.fontfile))
 382         file.write(">>\n")
 383
 384
 385 class PDFfontfile(PDFobject):
 386
 387     def __init__(self, name, filename, encoding, chars, writer, registry):
 388         PDFobject.__init__(self, "fontfile", filename)
 389         self.name = name
 390         self.filename = filename
 391         if encoding is None:
 392             self.encodingfilename = None
 393         else:
 394             self.encodingfilename = encoding.filename
 395         self.usedchars = {}
 396         for char in chars:
 397             self.usedchars[char] = 1
 398
 399         self.strip = 1
 400         self.font = None
 401
 402     def merge(self, other):
 403         if self.encodingfilename == other.encodingfilename:
 404             self.usedchars.update(other.usedchars)
 405         else:
 406             # TODO: need to resolve the encoding when several encodings are in the play
 407             self.strip = 0
 408
 409     def mkfontfile(self):
 410         import font.t1font
 411         self.font = font.t1font.T1pfbfont(self.filename)
 412
 413     def getflags(self):
 414         if self.font is None:
 415             self.mkfontfile()
 416         return self.font.getflags()
 417
 418     def write(self, file, writer, registry):
 419         if self.font is None:
 420             self.mkfontfile()
 421         if self.strip:
 422             # XXX: access to the encoding file
 423             if self.encodingfilename:
 424                 encodingfile = type1font.encodingfile(self.encodingfilename, self.encodingfilename)
 425                 usedglyphs = dict([(encodingfile.decode(char)[1:], 1) for char in self.usedchars.keys()])
 426             else:
 427                 self.font._encoding()
 428                 usedglyphs = dict([(self.font.encoding.decode(char), 1) for char in self.usedchars.keys()])
 429             strippedfont = self.font.getstrippedfont(usedglyphs)
 430         else:
 431             strippedfont = self.font
 432         strippedfont.outputPDF(file, writer)
 433
 434
 435 class PDFencoding(PDFobject):
 436
 437     def __init__(self, encoding, writer, registry):
 438         PDFobject.__init__(self, "encoding", encoding.name)
 439         self.encoding = encoding
 440
 441     def write(self, file, writer, registry):
 442         encodingfile = type1font.encodingfile(self.encoding.name, self.encoding.filename)
 443         encodingfile.outputPDF(file, writer)
 444
 445
 446 class PDFwriter:
 447
 448     def __init__(self, document, filename,
 449                        title=None, author=None, subject=None, keywords=None,
 450                        fullscreen=0, writebbox=0, compress=1, compresslevel=6):
 451         try:
 452             filename.write("")
 453         except:
 454             if not filename.endswith(".pdf"):
 455                 filename = filename + ".pdf"
 456             try:
 457                 file = open(filename, "wb")
 458             except IOError:
 459                 raise IOError("cannot open output file")
 460         else:
 461             file = filename
 462
 463         self.title = title
 464         self.author = author
 465         self.subject = subject
 466         self.keywords = keywords
 467         self.fullscreen = fullscreen
 468         self.writebbox = writebbox
 469         if compress and not haszlib:
 470             compress = 0
 471             warnings.warn("compression disabled due to missing zlib module")
 472         self.compress = compress
 473         self.compresslevel = compresslevel
 474
 475         # the PDFcatalog class automatically builds up the pdfobjects from a document
 476         registry = PDFregistry()
 477         catalog = PDFcatalog(document, self, registry)
 478         registry.add(catalog)
 479
 480         file.write("%%PDF-1.4\n%%%s%s%s%s\n" % (chr(195), chr(182), chr(195), chr(169)))
 481         registry.write(file, self, catalog)
 482         file.close()
 483
 484
 485 class context:
 486
 487     def __init__(self):
 488         self.linewidth_pt = None
 489         # XXX there are both stroke and fill color spaces
 490         self.colorspace = None
 491         self.strokeattr = 1
 492         self.fillattr = 1
 493         self.font = None
 494         self.textregion = 0
 495
 496     def __call__(self, **kwargs):
 497         newcontext = copy.copy(self)
 498         for key, value in kwargs.items():
 499             setattr(newcontext, key, value)
 500         return newcontext