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
  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=[], texrunner=None):
  72
  73         """construct a canvas
  74
  75         The canvas can be modfied by supplying args, 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 texrunner is not None:
  93             self.texrunner = texrunner
  94         else:
  95             # prevent cyclic imports
  96             import text
  97             self.texrunner = text.defaulttexrunner
  98
  99         attr.checkattrs(attrs, [trafo.trafo_pt, clip, style.strokestyle, style.fillstyle])
 100         # We have to reverse the trafos such that the PostScript concat operators
 101         # are in the right order. Correspondingly, we below multiply the current self.trafo
 102         # from the right.
 103         # Note that while for the stroke and fill styles the order doesn't matter at all,
 104         # this is not true for the clip operation.
 105         attrs = attrs[:]
 106         attrs.reverse()
 107         for aattr in attrs:
 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         if self.items:
 158             file.write("q\n") # gsave
 159             nbbox = bboxmodule.empty()
 160             for item in self.items:
 161                 if isinstance(item, font.text_pt):
 162                     if not context.textregion:
 163                         file.write("BT\n")
 164                         context.textregion = 1
 165                 else:
 166                     if context.textregion:
 167                         file.write("ET\n")
 168                         context.textregion = 0
 169                         context.font = None
 170                 item.processPDF(file, writer, context, registry, nbbox)
 171             if context.textregion:
 172                 file.write("ET\n")
 173                 context.textregion = 0
 174                 context.font = None
 175             # update bounding bbox
 176             nbbox.transform(self.trafo)
 177             if self.clipbbox is not None:
 178                 nbbox *= self.clipbbox
 179             bbox += nbbox
 180             file.write("Q\n") # grestore
 181
 182     def insert(self, item, attrs=None):
 183         """insert item in the canvas.
 184
 185         If attrs are passed, a canvas containing the item is inserted applying attrs.
 186
 187         returns the item
 188
 189         """
 190
 191         if not isinstance(item, canvasitem.canvasitem):
 192             raise RuntimeError("only instances of canvasitem.canvasitem can be inserted into a canvas")
 193
 194         if attrs:
 195             sc = _canvas(attrs)
 196             sc.insert(item)
 197             self.items.append(sc)
 198         else:
 199             self.items.append(item)
 200         return item
 201
 202     def draw(self, path, attrs):
 203         """draw path on canvas using the style given by args
 204
 205         The argument attrs consists of PathStyles, which modify
 206         the appearance of the path, PathDecos, which add some new
 207         visual elements to the path, or trafos, which are applied
 208         before drawing the path.
 209
 210         """
 211
 212         attrs = attr.mergeattrs(attrs)
 213         attr.checkattrs(attrs, [deco.deco, deformer.deformer, style.fillstyle, style.strokestyle])
 214
 215         for adeformer in attr.getattrs(attrs, [deformer.deformer]):
 216             path = adeformer.deform(path)
 217
 218         styles = attr.getattrs(attrs, [style.fillstyle, style.strokestyle])
 219         dp = deco.decoratedpath(path, styles=styles)
 220
 221         # add path decorations and modify path accordingly
 222         for adeco in attr.getattrs(attrs, [deco.deco]):
 223             adeco.decorate(dp, self.texrunner)
 224
 225         self.insert(dp)
 226
 227     def stroke(self, path, attrs=[]):
 228         """stroke path on canvas using the style given by args
 229
 230         The argument attrs consists of PathStyles, which modify
 231         the appearance of the path, PathDecos, which add some new
 232         visual elements to the path, or trafos, which are applied
 233         before drawing the path.
 234
 235         """
 236
 237         self.draw(path, [deco.stroked]+list(attrs))
 238
 239     def fill(self, path, attrs=[]):
 240         """fill path on canvas using the style given by args
 241
 242         The argument attrs consists of PathStyles, which modify
 243         the appearance of the path, PathDecos, which add some new
 244         visual elements to the path, or trafos, which are applied
 245         before drawing the path.
 246
 247         """
 248
 249         self.draw(path, [deco.filled]+list(attrs))
 250
 251     def settexrunner(self, texrunner):
 252         """sets the texrunner to be used to within the text and text_pt methods"""
 253
 254         self.texrunner = texrunner
 255
 256     def text(self, x, y, atext, *args, **kwargs):
 257         """insert a text into the canvas
 258
 259         inserts a textbox created by self.texrunner.text into the canvas
 260
 261         returns the inserted textbox"""
 262
 263         return self.insert(self.texrunner.text(x, y, atext, *args, **kwargs))
 264
 265
 266     def text_pt(self, x, y, atext, *args):
 267         """insert a text into the canvas
 268
 269         inserts a textbox created by self.texrunner.text_pt into the canvas
 270
 271         returns the inserted textbox"""
 272
 273         return self.insert(self.texrunner.text_pt(x, y, atext, *args))
 274
 275 #
 276 # user canvas class which adds a few convenience methods for single page output
 277 #
 278
 279 def _wrappedindocument(method):
 280     def wrappedindocument(self, file=None, **kwargs):
 281         d = document.document([document.page(self, **kwargs)])
 282         self.__name__ = method.__name__
 283         self.__doc__ = method.__doc__
 284         return method(d, file)
 285     return wrappedindocument
 286
 287
 288 class canvas(_canvas):
 289
 290     """a canvas holds a collection of canvasitems"""
 291
 292     writeEPSfile = _wrappedindocument(document.document.writeEPSfile)
 293     writePSfile = _wrappedindocument(document.document.writePSfile)
 294     writePDFfile = _wrappedindocument(document.document.writePDFfile)
 295     writetofile = _wrappedindocument(document.document.writetofile)
 296
 297     def pipeGS(self, filename="-", device=None, resolution=100,
 298                gscommand="gs", gsoptions="",
 299                textalphabits=4, graphicsalphabits=4,
 300                **kwargs):
 301         if device is None:
 302             if filename.endswith(".png"):
 303                 device = "png16m"
 304             if filename.endswith(".jpg"):
 305                 device = "jpeg"
 306         gscommand += " -dEPSCrop -dNOPAUSE -dQUIET -dBATCH -r%i -sDEVICE=%s -sOutputFile=%s" % (resolution, device, filename)
 307         if gsoptions:
 308             gscommand += " %s" % gsoptions
 309         if textalphabits is not None:
 310             gscommand += " -dTextAlphaBits=%i" % textalphabits
 311         if graphicsalphabits is not None:
 312             gscommand += " -dGraphicsAlphaBits=%i" % graphicsalphabits
 313         gscommand += " -"
 314         input = os.popen(gscommand, "w")
 315         self.writeEPSfile(input, **kwargs)