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=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         if attrs is not None:
 108             for aattr in attrs[::-1]:
 109                 if isinstance(aattr, trafo.trafo_pt):
 110                     self.trafo = self.trafo * aattr
 111                 elif isinstance(aattr, clip):
 112                     if self.clipbbox is None:
 113                         self.clipbbox = aattr.clipbbox().transformed(self.trafo)
 114                     else:
 115                         self.clippbox *= aattr.clipbbox().transformed(self.trafo)
 116                 self.items.append(aattr)
 117
 118     def __len__(self):
 119         return len(self.items)
 120
 121     def __getitem__(self, i):
 122         return self.items[i]
 123
 124     def bbox(self):
 125         """returns bounding box of canvas
 126
 127         Note that this bounding box doesn't take into account the linewidths, so
 128         is less accurate than the one used when writing the output to a file.
 129         """
 130         obbox = bboxmodule.empty()
 131         for cmd in self.items:
 132             obbox += cmd.bbox()
 133
 134         # transform according to our global transformation and
 135         # intersect with clipping bounding box (which has already been
 136         # transformed in canvas.__init__())
 137         obbox.transform(self.trafo)
 138         if self.clipbbox is not None:
 139             obbox *= self.clipbbox
 140         return obbox
 141
 142     def processPS(self, file, writer, context, registry, bbox):
 143         context = context()
 144         if self.items:
 145             file.write("gsave\n")
 146             nbbox = bboxmodule.empty()
 147             for item in self.items:
 148                 item.processPS(file, writer, context, registry, nbbox)
 149             # update bounding bbox
 150             nbbox.transform(self.trafo)
 151             if self.clipbbox is not None:
 152                 nbbox *= self.clipbbox
 153             bbox += nbbox
 154             file.write("grestore\n")
 155
 156     def processPDF(self, file, writer, context, registry, bbox):
 157         context = context()
 158         if self.items:
 159             file.write("q\n") # gsave
 160             nbbox = bboxmodule.empty()
 161             for item in self.items:
 162                 if isinstance(item, font.text_pt):
 163                     if not context.textregion:
 164                         file.write("BT\n")
 165                         context.textregion = 1
 166                 else:
 167                     if context.textregion:
 168                         file.write("ET\n")
 169                         context.textregion = 0
 170                         context.selectedfont = None
 171                 item.processPDF(file, writer, context, registry, nbbox)
 172             if context.textregion:
 173                 file.write("ET\n")
 174                 context.textregion = 0
 175                 context.selectedfont = None
 176             # update bounding bbox
 177             nbbox.transform(self.trafo)
 178             if self.clipbbox is not None:
 179                 nbbox *= self.clipbbox
 180             bbox += nbbox
 181             file.write("Q\n") # grestore
 182
 183     def insert(self, item, attrs=None):
 184         """insert item in the canvas.
 185
 186         If attrs are passed, a canvas containing the item is inserted applying attrs.
 187
 188         returns the item
 189
 190         """
 191
 192         if not isinstance(item, canvasitem.canvasitem):
 193             raise RuntimeError("only instances of canvasitem.canvasitem can be inserted into a canvas")
 194
 195         if attrs:
 196             sc = _canvas(attrs)
 197             sc.insert(item)
 198             self.items.append(sc)
 199         else:
 200             self.items.append(item)
 201         return item
 202
 203     def draw(self, path, attrs):
 204         """draw path on canvas using the style given by args
 205
 206         The argument attrs consists of PathStyles, which modify
 207         the appearance of the path, PathDecos, which add some new
 208         visual elements to the path, or trafos, which are applied
 209         before drawing the path.
 210
 211         """
 212
 213         attrs = attr.mergeattrs(attrs)
 214         attr.checkattrs(attrs, [deco.deco, deformer.deformer, style.fillstyle, style.strokestyle])
 215
 216         for adeformer in attr.getattrs(attrs, [deformer.deformer]):
 217             path = adeformer.deform(path)
 218
 219         styles = attr.getattrs(attrs, [style.fillstyle, style.strokestyle])
 220         dp = deco.decoratedpath(path, styles=styles)
 221
 222         # add path decorations and modify path accordingly
 223         for adeco in attr.getattrs(attrs, [deco.deco]):
 224             adeco.decorate(dp, self.texrunner)
 225
 226         self.insert(dp)
 227
 228     def stroke(self, path, attrs=[]):
 229         """stroke path on canvas using the style given by args
 230
 231         The argument attrs consists of PathStyles, which modify
 232         the appearance of the path, PathDecos, which add some new
 233         visual elements to the path, or trafos, which are applied
 234         before drawing the path.
 235
 236         """
 237
 238         self.draw(path, [deco.stroked]+list(attrs))
 239
 240     def fill(self, path, attrs=[]):
 241         """fill path on canvas using the style given by args
 242
 243         The argument attrs consists of PathStyles, which modify
 244         the appearance of the path, PathDecos, which add some new
 245         visual elements to the path, or trafos, which are applied
 246         before drawing the path.
 247
 248         """
 249
 250         self.draw(path, [deco.filled]+list(attrs))
 251
 252     def settexrunner(self, texrunner):
 253         """sets the texrunner to be used to within the text and text_pt methods"""
 254
 255         self.texrunner = texrunner
 256
 257     def text(self, x, y, atext, *args, **kwargs):
 258         """insert a text into the canvas
 259
 260         inserts a textbox created by self.texrunner.text into the canvas
 261
 262         returns the inserted textbox"""
 263
 264         return self.insert(self.texrunner.text(x, y, atext, *args, **kwargs))
 265
 266
 267     def text_pt(self, x, y, atext, *args):
 268         """insert a text into the canvas
 269
 270         inserts a textbox created by self.texrunner.text_pt into the canvas
 271
 272         returns the inserted textbox"""
 273
 274         return self.insert(self.texrunner.text_pt(x, y, atext, *args))
 275
 276 #
 277 # user canvas class which adds a few convenience methods for single page output
 278 #
 279
 280 def _wrappedindocument(method):
 281     def wrappedindocument(self, file=None, **kwargs):
 282         d = document.document([document.page(self, **kwargs)])
 283         self.__name__ = method.__name__
 284         self.__doc__ = method.__doc__
 285         return method(d, file)
 286     return wrappedindocument
 287
 288
 289 class canvas(_canvas):
 290
 291     """a canvas holds a collection of canvasitems"""
 292
 293     writeEPSfile = _wrappedindocument(document.document.writeEPSfile)
 294     writePSfile = _wrappedindocument(document.document.writePSfile)
 295     writePDFfile = _wrappedindocument(document.document.writePDFfile)
 296     writetofile = _wrappedindocument(document.document.writetofile)
 297
 298     def pipeGS(self, filename="-", device=None, resolution=100,
 299                gscommand="gs", gsoptions="",
 300                textalphabits=4, graphicsalphabits=4,
 301                **kwargs):
 302         if device is None:
 303             if filename.endswith(".png"):
 304                 device = "png16m"
 305             if filename.endswith(".jpg"):
 306                 device = "jpeg"
 307         gscommand += " -dEPSCrop -dNOPAUSE -dQUIET -dBATCH -r%i -sDEVICE=%s -sOutputFile=%s" % (resolution, device, filename)
 308         if gsoptions:
 309             gscommand += " %s" % gsoptions
 310         if textalphabits is not None:
 311             gscommand += " -dTextAlphaBits=%i" % textalphabits
 312         if graphicsalphabits is not None:
 313             gscommand += " -dGraphicsAlphaBits=%i" % graphicsalphabits
 314         gscommand += " -"
 315         input = os.popen(gscommand, "w")
 316         self.writeEPSfile(input, **kwargs)