pyx/canvas.py

   1 # -*- coding: ISO-8859-1 -*-
   2 #
   3 #
   4 # Copyright (C) 2002-2006 Jörg Lehmann <joergl@users.sourceforge.net>
   5 # Copyright (C) 2002-2006 André Wobst <wobsta@users.sourceforge.net>
   6 #
   7 # This file is part of PyX (http://pyx.sourceforge.net/).
   8 #
   9 # PyX is free software; you can redistribute it and/or modify
  10 # it under the terms of the GNU General Public License as published by
  11 # the Free Software Foundation; either version 2 of the License, or
  12 # (at your option) any later version.
  13 #
  14 # PyX is distributed in the hope that it will be useful,
  15 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17 # GNU General Public License for more details.
  18 #
  19 # You should have received a copy of the GNU General Public License
  20 # along with PyX; if not, write to the Free Software
  21 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
  22
  23 """The canvas module provides a PostScript canvas class and related classes
  24
  25 A canvas holds a collection of all elements and corresponding attributes to be
  26 displayed. """
  27
  28 import os, tempfile
  29 import attr, canvasitem, deco, deformer, document, font, style, trafo
  30 import bbox as bboxmodule
  31
  32
  33 #
  34 # clipping class
  35 #
  36
  37 class clip(canvasitem.canvasitem):
  38
  39     """class for use in canvas constructor which clips to a path"""
  40
  41     def __init__(self, path):
  42         """construct a clip instance for a given path"""
  43         self.path = path
  44
  45     def bbox(self):
  46         # as a canvasitem a clipping path has NO influence on the bbox...
  47         return bboxmodule.empty()
  48
  49     def clipbbox(self):
  50         # ... but for clipping, we nevertheless need the bbox
  51         return self.path.bbox()
  52
  53     def processPS(self, file, writer, context, registry, bbox):
  54         file.write("newpath\n")
  55         self.path.outputPS(file, writer)
  56         file.write("clip\n")
  57
  58     def processPDF(self, file, writer, context, registry, bbox):
  59         self.path.outputPDF(file, writer)
  60         file.write("W n\n")
  61
  62
  63 #
  64 # general canvas class
  65 #
  66
  67 class _canvas(canvasitem.canvasitem):
  68
  69     """a canvas holds a collection of canvasitems"""
  70
  71     def __init__(self, attrs=None, texrunner=None):
  72
  73         """construct a canvas
  74
  75         The canvas can be modfied by supplying a list of attrs, which have
  76         to be instances of one of the following classes:
  77          - trafo.trafo (leading to a global transformation of the canvas)
  78          - canvas.clip (clips the canvas)
  79          - style.strokestyle, style.fillstyle (sets some global attributes of the canvas)
  80
  81         Note that, while the first two properties are fixed for the
  82         whole canvas, the last one can be changed via canvas.set().
  83
  84         The texrunner instance used for the text method can be specified
  85         using the texrunner argument. It defaults to text.defaulttexrunner
  86
  87         """
  88
  89         self.items     = []
  90         self.trafo     = trafo.trafo()
  91         self.clipbbox  = None
  92         if attrs is None:
  93             attrs = []
  94         if texrunner is not None:
  95             self.texrunner = texrunner
  96         else:
  97             # prevent cyclic imports
  98             import text
  99             self.texrunner = text.defaulttexrunner
 100
 101         attr.checkattrs(attrs, [trafo.trafo_pt, clip, style.strokestyle, style.fillstyle])
 102         # We have to reverse the trafos such that the PostScript concat operators
 103         # are in the right order. Correspondingly, we below multiply the current self.trafo
 104         # from the right.
 105         # Note that while for the stroke and fill styles the order doesn't matter at all,
 106         # this is not true for the clip operation.
 107         for aattr in attrs[::-1]:
 108             if isinstance(aattr, trafo.trafo_pt):
 109                 self.trafo = self.trafo * aattr
 110             elif isinstance(aattr, clip):
 111                 if self.clipbbox is None:
 112                     self.clipbbox = aattr.clipbbox().transformed(self.trafo)
 113                 else:
 114                     self.clippbox *= aattr.clipbbox().transformed(self.trafo)
 115             self.items.append(aattr)
 116
 117     def __len__(self):
 118         return len(self.items)
 119
 120     def __getitem__(self, i):
 121         return self.items[i]
 122
 123     def bbox(self):
 124         """returns bounding box of canvas
 125
 126         Note that this bounding box doesn't take into account the linewidths, so
 127         is less accurate than the one used when writing the output to a file.
 128         """
 129         obbox = bboxmodule.empty()
 130         for cmd in self.items:
 131             obbox += cmd.bbox()
 132
 133         # transform according to our global transformation and
 134         # intersect with clipping bounding box (which has already been
 135         # transformed in canvas.__init__())
 136         obbox.transform(self.trafo)
 137         if self.clipbbox is not None:
 138             obbox *= self.clipbbox
 139         return obbox
 140
 141     def processPS(self, file, writer, context, registry, bbox):
 142         context = context()
 143         if self.items:
 144             file.write("gsave\n")
 145             nbbox = bboxmodule.empty()
 146             for item in self.items:
 147                 item.processPS(file, writer, context, registry, nbbox)
 148             # update bounding bbox
 149             nbbox.transform(self.trafo)
 150             if self.clipbbox is not None:
 151                 nbbox *= self.clipbbox
 152             bbox += nbbox
 153             file.write("grestore\n")
 154
 155     def processPDF(self, file, writer, context, registry, bbox):
 156         context = context()
 157         context.trafo = context.trafo * self.trafo
 158         if self.items:
 159             file.write("q\n") # gsave
 160             nbbox = bboxmodule.empty()
 161             for item in self.items:
 162                 if isinstance(item, style.fillstyle):
 163                     context.fillstyles.append(item)
 164                 if not writer.textaspath:
 165                     if isinstance(item, font.text_pt):
 166                         if not context.textregion:
 167                             file.write("BT\n")
 168                             context.textregion = 1
 169                     else:
 170                         if context.textregion:
 171                             file.write("ET\n")
 172                             context.textregion = 0
 173                             context.selectedfont = None
 174                 item.processPDF(file, writer, context, registry, nbbox)
 175             if context.textregion:
 176                 file.write("ET\n")
 177                 context.textregion = 0
 178                 context.selectedfont = None
 179             # update bounding bbox
 180             nbbox.transform(self.trafo)
 181             if self.clipbbox is not None:
 182                 nbbox *= self.clipbbox
 183             bbox += nbbox
 184             file.write("Q\n") # grestore
 185
 186     def insert(self, item, attrs=None):
 187         """insert item in the canvas.
 188
 189         If attrs are passed, a canvas containing the item is inserted applying attrs.
 190
 191         returns the item
 192
 193         """
 194
 195         if not isinstance(item, canvasitem.canvasitem):
 196             raise RuntimeError("only instances of canvasitem.canvasitem can be inserted into a canvas")
 197
 198         if attrs:
 199             sc = _canvas(attrs)
 200             sc.insert(item)
 201             self.items.append(sc)
 202         else:
 203             self.items.append(item)
 204         return item
 205
 206     def draw(self, path, attrs):
 207         """draw path on canvas using the style given by args
 208
 209         The argument attrs consists of PathStyles, which modify
 210         the appearance of the path, PathDecos, which add some new
 211         visual elements to the path, or trafos, which are applied
 212         before drawing the path.
 213
 214         """
 215
 216         attrs = attr.mergeattrs(attrs)
 217         attr.checkattrs(attrs, [deco.deco, deformer.deformer, style.fillstyle, style.strokestyle])
 218
 219         for adeformer in attr.getattrs(attrs, [deformer.deformer]):
 220             path = adeformer.deform(path)
 221
 222         styles = attr.getattrs(attrs, [style.fillstyle, style.strokestyle])
 223         dp = deco.decoratedpath(path, styles=styles)
 224
 225         # add path decorations and modify path accordingly
 226         for adeco in attr.getattrs(attrs, [deco.deco]):
 227             adeco.decorate(dp, self.texrunner)
 228
 229         self.insert(dp)
 230
 231     def stroke(self, path, attrs=[]):
 232         """stroke path on canvas using the style given by args
 233
 234         The argument attrs consists of PathStyles, which modify
 235         the appearance of the path, PathDecos, which add some new
 236         visual elements to the path, or trafos, which are applied
 237         before drawing the path.
 238
 239         """
 240
 241         self.draw(path, [deco.stroked]+list(attrs))
 242
 243     def fill(self, path, attrs=[]):
 244         """fill path on canvas using the style given by args
 245
 246         The argument attrs consists of PathStyles, which modify
 247         the appearance of the path, PathDecos, which add some new
 248         visual elements to the path, or trafos, which are applied
 249         before drawing the path.
 250
 251         """
 252
 253         self.draw(path, [deco.filled]+list(attrs))
 254
 255     def settexrunner(self, texrunner):
 256         """sets the texrunner to be used to within the text and text_pt methods"""
 257
 258         self.texrunner = texrunner
 259
 260     def text(self, x, y, atext, *args, **kwargs):
 261         """insert a text into the canvas
 262
 263         inserts a textbox created by self.texrunner.text into the canvas
 264
 265         returns the inserted textbox"""
 266
 267         return self.insert(self.texrunner.text(x, y, atext, *args, **kwargs))
 268
 269
 270     def text_pt(self, x, y, atext, *args):
 271         """insert a text into the canvas
 272
 273         inserts a textbox created by self.texrunner.text_pt into the canvas
 274
 275         returns the inserted textbox"""
 276
 277         return self.insert(self.texrunner.text_pt(x, y, atext, *args))
 278
 279 #
 280 # user canvas class which adds a few convenience methods for single page output
 281 #
 282
 283 def _wrappedindocument(method):
 284     def wrappedindocument(self, file=None, **kwargs):
 285         d = document.document([document.page(self, **kwargs)])
 286         self.__name__ = method.__name__
 287         self.__doc__ = method.__doc__
 288         return method(d, file)
 289     return wrappedindocument
 290
 291
 292 class canvas(_canvas):
 293
 294     """a canvas holds a collection of canvasitems"""
 295
 296     writeEPSfile = _wrappedindocument(document.document.writeEPSfile)
 297     writePSfile = _wrappedindocument(document.document.writePSfile)
 298     writePDFfile = _wrappedindocument(document.document.writePDFfile)
 299     writetofile = _wrappedindocument(document.document.writetofile)
 300
 301     def pipeGS(self, filename="-", device=None, resolution=100,
 302                gscommand="gs", gsoptions="",
 303                textalphabits=4, graphicsalphabits=4,
 304                ciecolor=False, input="eps", **kwargs):
 305         if device is None:
 306             if filename.endswith(".png"):
 307                 device = "png16m"
 308             if filename.endswith(".jpg"):
 309                 device = "jpeg"
 310         gscommand += " -dEPSCrop -dNOPAUSE -dQUIET -dBATCH -r%i -sDEVICE=%s -sOutputFile=%s" % (resolution, device, filename)
 311         if gsoptions:
 312             gscommand += " %s" % gsoptions
 313         if textalphabits is not None:
 314             gscommand += " -dTextAlphaBits=%i" % textalphabits
 315         if graphicsalphabits is not None:
 316             gscommand += " -dGraphicsAlphaBits=%i" % graphicsalphabits
 317         if ciecolor:
 318             gscommand += " -dUseCIEColor"
 319         if input == "eps":
 320             gscommand += " -"
 321             pipe = os.popen(gscommand, "wb")
 322             self.writeEPSfile(pipe, **kwargs)
 323         elif input == "pdf":
 324             fd, fname = tempfile.mkstemp()
 325             f = os.fdopen(fd, "wb")
 326             gscommand += " %s" % fname
 327             self.writePDFfile(f, **kwargs)
 328             f.close()
 329             os.system(gscommand)
 330             os.unlink(fname)
 331         else:
 332             raise RuntimeError("input 'eps' or 'pdf' expected")