1 # -*- coding: ISO-8859-1 -*-
4 # Copyright (C) 2002-2006 Jörg Lehmann <joergl@users.sourceforge.net>
5 # Copyright (C) 2002-2006 André Wobst <wobsta@users.sourceforge.net>
7 # This file is part of PyX (http://pyx.sourceforge.net/).
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.
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.
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
23 """The canvas module provides a PostScript canvas class and related classes
25 A canvas holds a collection of all elements and corresponding attributes to be
29 import attr
, canvasitem
, deco
, deformer
, document
, font
, style
, trafo
30 import bbox
as bboxmodule
37 class clip(canvasitem
.canvasitem
):
39 """class for use in canvas constructor which clips to a path"""
41 def __init__(self
, path
):
42 """construct a clip instance for a given path"""
46 # as a canvasitem a clipping path has NO influence on the bbox...
47 return bboxmodule
.empty()
50 # ... but for clipping, we nevertheless need the bbox
51 return self
.path
.bbox()
53 def processPS(self
, file, writer
, context
, registry
, bbox
):
54 file.write("newpath\n")
55 self
.path
.outputPS(file, writer
)
58 def processPDF(self
, file, writer
, context
, registry
, bbox
):
59 self
.path
.outputPDF(file, writer
)
64 # general canvas class
67 class _canvas(canvasitem
.canvasitem
):
69 """a canvas holds a collection of canvasitems"""
71 def __init__(self
, attrs
=None, texrunner
=None):
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)
81 Note that, while the first two properties are fixed for the
82 whole canvas, the last one can be changed via canvas.set().
84 The texrunner instance used for the text method can be specified
85 using the texrunner argument. It defaults to text.defaulttexrunner
90 self
.trafo
= trafo
.trafo()
94 if texrunner
is not None:
95 self
.texrunner
= texrunner
97 # prevent cyclic imports
99 self
.texrunner
= text
.defaulttexrunner
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
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
)
114 self
.clippbox
*= aattr
.clipbbox().transformed(self
.trafo
)
115 self
.items
.append(aattr
)
118 return len(self
.items
)
120 def __getitem__(self
, i
):
124 """returns bounding box of canvas
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.
129 obbox
= bboxmodule
.empty()
130 for cmd
in self
.items
:
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
141 def processPS(self
, file, writer
, context
, registry
, bbox
):
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
153 file.write("grestore\n")
155 def processPDF(self
, file, writer
, context
, registry
, bbox
):
158 file.write("q\n") # gsave
159 nbbox
= bboxmodule
.empty()
160 for item
in self
.items
:
161 if not writer
.textaspath
:
162 if isinstance(item
, font
.text_pt
):
163 if not context
.textregion
:
165 context
.textregion
= 1
167 if context
.textregion
:
169 context
.textregion
= 0
170 context
.selectedfont
= None
171 item
.processPDF(file, writer
, context
, registry
, nbbox
)
172 if context
.textregion
:
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
181 file.write("Q\n") # grestore
183 def insert(self
, item
, attrs
=None):
184 """insert item in the canvas.
186 If attrs are passed, a canvas containing the item is inserted applying attrs.
192 if not isinstance(item
, canvasitem
.canvasitem
):
193 raise RuntimeError("only instances of canvasitem.canvasitem can be inserted into a canvas")
198 self
.items
.append(sc
)
200 self
.items
.append(item
)
203 def draw(self
, path
, attrs
):
204 """draw path on canvas using the style given by args
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.
213 attrs
= attr
.mergeattrs(attrs
)
214 attr
.checkattrs(attrs
, [deco
.deco
, deformer
.deformer
, style
.fillstyle
, style
.strokestyle
])
216 for adeformer
in attr
.getattrs(attrs
, [deformer
.deformer
]):
217 path
= adeformer
.deform(path
)
219 styles
= attr
.getattrs(attrs
, [style
.fillstyle
, style
.strokestyle
])
220 dp
= deco
.decoratedpath(path
, styles
=styles
)
222 # add path decorations and modify path accordingly
223 for adeco
in attr
.getattrs(attrs
, [deco
.deco
]):
224 adeco
.decorate(dp
, self
.texrunner
)
228 def stroke(self
, path
, attrs
=[]):
229 """stroke path on canvas using the style given by args
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.
238 self
.draw(path
, [deco
.stroked
]+list(attrs
))
240 def fill(self
, path
, attrs
=[]):
241 """fill path on canvas using the style given by args
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.
250 self
.draw(path
, [deco
.filled
]+list(attrs
))
252 def settexrunner(self
, texrunner
):
253 """sets the texrunner to be used to within the text and text_pt methods"""
255 self
.texrunner
= texrunner
257 def text(self
, x
, y
, atext
, *args
, **kwargs
):
258 """insert a text into the canvas
260 inserts a textbox created by self.texrunner.text into the canvas
262 returns the inserted textbox"""
264 return self
.insert(self
.texrunner
.text(x
, y
, atext
, *args
, **kwargs
))
267 def text_pt(self
, x
, y
, atext
, *args
):
268 """insert a text into the canvas
270 inserts a textbox created by self.texrunner.text_pt into the canvas
272 returns the inserted textbox"""
274 return self
.insert(self
.texrunner
.text_pt(x
, y
, atext
, *args
))
277 # user canvas class which adds a few convenience methods for single page output
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
289 class canvas(_canvas
):
291 """a canvas holds a collection of canvasitems"""
293 writeEPSfile
= _wrappedindocument(document
.document
.writeEPSfile
)
294 writePSfile
= _wrappedindocument(document
.document
.writePSfile
)
295 writePDFfile
= _wrappedindocument(document
.document
.writePDFfile
)
296 writetofile
= _wrappedindocument(document
.document
.writetofile
)
298 def pipeGS(self
, filename
="-", device
=None, resolution
=100,
299 gscommand
="gs", gsoptions
="",
300 textalphabits
=4, graphicsalphabits
=4,
303 if filename
.endswith(".png"):
305 if filename
.endswith(".jpg"):
307 gscommand
+= " -dEPSCrop -dNOPAUSE -dQUIET -dBATCH -r%i -sDEVICE=%s -sOutputFile=%s" % (resolution
, device
, filename
)
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
315 input = os
.popen(gscommand
, "w")
316 self
.writeEPSfile(input, **kwargs
)