pyx/deco.py

   1 # -*- encoding: utf-8 -*-
   2 #
   3 #
   4 # Copyright (C) 2002-2011 Jörg Lehmann <joergl@users.sourceforge.net>
   5 # Copyright (C) 2003-2011 Michael Schindler <m-schindler@users.sourceforge.net>
   6 # Copyright (C) 2002-2011 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 # TODO:
  25 # - should we improve on the arc length -> arg parametrization routine or
  26 #   should we at least factor it out?
  27
  28 import sys, math
  29 import attr, canvas, canvasitem, color, path, normpath, style, trafo, unit, deformer
  30
  31 _marker = object()
  32
  33 #
  34 # Decorated path
  35 #
  36
  37 class decoratedpath(canvasitem.canvasitem):
  38     """Decorated path
  39
  40     The main purpose of this class is during the drawing
  41     (stroking/filling) of a path. It collects attributes for the
  42     stroke and/or fill operations.
  43     """
  44
  45     def __init__(self, path, strokepath=None, fillpath=None,
  46                  styles=None, strokestyles=None, fillstyles=None,
  47                  ornaments=None, fillrule=style.fillrule.nonzero_winding):
  48
  49         self.path = path
  50
  51         # global style for stroking and filling and subdps
  52         self.styles = styles
  53
  54         # styles which apply only for stroking and filling
  55         self.strokestyles = strokestyles
  56         self.fillstyles = fillstyles
  57
  58         # the decoratedpath can contain additional elements of the
  59         # path (ornaments), e.g., arrowheads.
  60         if ornaments is None:
  61             self.ornaments = canvas.canvas()
  62         else:
  63             self.ornaments = ornaments
  64
  65         # the fillrule is either fillrule.nonzero_winding or fillrule.even_odd
  66         self.fillrule = fillrule
  67
  68         self.nostrokeranges = None
  69
  70     def ensurenormpath(self):
  71         """convert self.path into a normpath"""
  72         assert self.nostrokeranges is None or isinstance(self.path, path.normpath), "you don't understand what you are doing"
  73         self.path = self.path.normpath()
  74
  75     def excluderange(self, begin, end):
  76         assert isinstance(self.path, path.normpath), "you don't understand what this is about"
  77         if self.nostrokeranges is None:
  78             self.nostrokeranges = [(begin, end)]
  79         else:
  80             ibegin = 0
  81             while ibegin < len(self.nostrokeranges) and self.nostrokeranges[ibegin][1] < begin:
  82                 ibegin += 1
  83
  84             if ibegin == len(self.nostrokeranges):
  85                 self.nostrokeranges.append((begin, end))
  86                 return
  87
  88             iend = len(self.nostrokeranges) - 1
  89             while 0 <= iend and end < self.nostrokeranges[iend][0]:
  90                 iend -= 1
  91
  92             if iend == -1:
  93                 self.nostrokeranges.insert(0, (begin, end))
  94                 return
  95
  96             if self.nostrokeranges[ibegin][0] < begin:
  97                 begin = self.nostrokeranges[ibegin][0]
  98             if end < self.nostrokeranges[iend][1]:
  99                 end = self.nostrokeranges[iend][1]
 100
 101             self.nostrokeranges[ibegin:iend+1] = [(begin, end)]
 102
 103     def bbox(self):
 104         pathbbox = self.path.bbox()
 105         ornamentsbbox = self.ornaments.bbox()
 106         if ornamentsbbox is not None:
 107             return ornamentsbbox + pathbbox
 108         else:
 109             return pathbbox
 110
 111     def strokepath(self):
 112         if self.nostrokeranges:
 113             splitlist = []
 114             for begin, end in self.nostrokeranges:
 115                 splitlist.append(begin)
 116                 splitlist.append(end)
 117             split = self.path.split(splitlist)
 118             # XXX properly handle closed paths?
 119             result = split[0]
 120             for i in range(2, len(split), 2):
 121                 result += split[i]
 122             return result
 123         else:
 124             return self.path
 125
 126     def processPS(self, file, writer, context, registry, bbox):
 127         # draw (stroke and/or fill) the decoratedpath on the canvas
 128         # while trying to produce an efficient output, e.g., by
 129         # not writing one path two times
 130
 131         # small helper
 132         def _writestyles(styles, context, registry, bbox):
 133             for style in styles:
 134                 style.processPS(file, writer, context, registry, bbox)
 135
 136         if self.strokestyles is None and self.fillstyles is None:
 137             if not len(self.ornaments):
 138                 raise RuntimeError("Path neither to be stroked nor filled nor decorated in another way")
 139             # just draw additional elements of decoratedpath
 140             self.ornaments.processPS(file, writer, context, registry, bbox)
 141             return
 142
 143         strokepath = self.strokepath()
 144         fillpath = self.path
 145
 146         # apply global styles
 147         if self.styles:
 148             file.write("gsave\n")
 149             context = context()
 150             _writestyles(self.styles, context, registry, bbox)
 151
 152         if self.fillstyles is not None:
 153             file.write("newpath\n")
 154             fillpath.outputPS(file, writer)
 155
 156             if self.strokestyles is not None and strokepath is fillpath:
 157                 # do efficient stroking + filling if respective paths are identical
 158                 file.write("gsave\n")
 159
 160                 if self.fillstyles:
 161                     _writestyles(self.fillstyles, context(), registry, bbox)
 162
 163                 if self.fillrule.even_odd:
 164                     file.write("eofill\n")
 165                 else:
 166                     file.write("fill\n")
 167                 file.write("grestore\n")
 168
 169                 acontext = context()
 170                 if self.strokestyles:
 171                     file.write("gsave\n")
 172                     _writestyles(self.strokestyles, acontext, registry, bbox)
 173
 174                 file.write("stroke\n")
 175                 # take linewidth into account for bbox when stroking a path
 176                 bbox += strokepath.bbox().enlarged_pt(0.5*acontext.linewidth_pt)
 177
 178                 if self.strokestyles:
 179                     file.write("grestore\n")
 180             else:
 181                 # only fill fillpath - for the moment
 182                 if self.fillstyles:
 183                     file.write("gsave\n")
 184                     _writestyles(self.fillstyles, context(), registry, bbox)
 185
 186                 if self.fillrule.even_odd:
 187                     file.write("eofill\n")
 188                 else:
 189                     file.write("fill\n")
 190                 bbox += fillpath.bbox()
 191
 192                 if self.fillstyles:
 193                     file.write("grestore\n")
 194
 195         if self.strokestyles is not None and (strokepath is not fillpath or self.fillstyles is None):
 196             # this is the only relevant case still left
 197             # Note that a possible stroking has already been done.
 198             acontext = context()
 199             if self.strokestyles:
 200                 file.write("gsave\n")
 201                 _writestyles(self.strokestyles, acontext, registry, bbox)
 202
 203             file.write("newpath\n")
 204             strokepath.outputPS(file, writer)
 205             file.write("stroke\n")
 206             # take linewidth into account for bbox when stroking a path
 207             bbox += strokepath.bbox().enlarged_pt(0.5*acontext.linewidth_pt)
 208
 209             if self.strokestyles:
 210                 file.write("grestore\n")
 211
 212         # now, draw additional elements of decoratedpath
 213         self.ornaments.processPS(file, writer, context, registry, bbox)
 214
 215         # restore global styles
 216         if self.styles:
 217             file.write("grestore\n")
 218
 219     def processPDF(self, file, writer, context, registry, bbox):
 220         # draw (stroke and/or fill) the decoratedpath on the canvas
 221
 222         def _writestyles(styles, context, registry, bbox):
 223             for style in styles:
 224                 style.processPDF(file, writer, context, registry, bbox)
 225
 226         def _writestrokestyles(strokestyles, context, registry, bbox):
 227             context.fillattr = 0
 228             for style in strokestyles:
 229                 style.processPDF(file, writer, context, registry, bbox)
 230             context.fillattr = 1
 231
 232         def _writefillstyles(fillstyles, context, registry, bbox):
 233             context.strokeattr = 0
 234             for style in fillstyles:
 235                 style.processPDF(file, writer, context, registry, bbox)
 236             context.strokeattr = 1
 237
 238         if self.strokestyles is None and self.fillstyles is None:
 239             if not len(self.ornaments):
 240                 raise RuntimeError("Path neither to be stroked nor filled nor decorated in another way")
 241             # just draw additional elements of decoratedpath
 242             self.ornaments.processPDF(file, writer, context, registry, bbox)
 243             return
 244
 245         strokepath = self.strokepath()
 246         fillpath = self.path
 247
 248         # apply global styles
 249         if self.styles:
 250             file.write("q\n") # gsave
 251             context = context()
 252             _writestyles(self.styles, context, registry, bbox)
 253
 254         if self.fillstyles is not None:
 255             fillpath.outputPDF(file, writer)
 256
 257             if self.strokestyles is not None and strokepath is fillpath:
 258                 # do efficient stroking + filling
 259                 file.write("q\n") # gsave
 260                 acontext = context()
 261
 262                 if self.fillstyles:
 263                     _writefillstyles(self.fillstyles, acontext, registry, bbox)
 264                 if self.strokestyles:
 265                     _writestrokestyles(self.strokestyles, acontext, registry, bbox)
 266
 267                 if self.fillrule.even_odd:
 268                     file.write("B*\n")
 269                 else:
 270                     file.write("B\n") # both stroke and fill
 271                 # take linewidth into account for bbox when stroking a path
 272                 bbox += strokepath.bbox().enlarged_pt(0.5*acontext.linewidth_pt)
 273
 274                 file.write("Q\n") # grestore
 275             else:
 276                 # only fill fillpath - for the moment
 277                 if self.fillstyles:
 278                     file.write("q\n") # gsave
 279                     _writefillstyles(self.fillstyles, context(), registry, bbox)
 280
 281                 if self.fillrule.even_odd:
 282                     file.write("f*\n")
 283                 else:
 284                     file.write("f\n") # fill
 285                 bbox += fillpath.bbox()
 286
 287                 if self.fillstyles:
 288                     file.write("Q\n") # grestore
 289
 290         if self.strokestyles is not None and (strokepath is not fillpath or self.fillstyles is None):
 291             # this is the only relevant case still left
 292             # Note that a possible stroking has already been done.
 293             acontext = context()
 294
 295             if self.strokestyles:
 296                 file.write("q\n") # gsave
 297                 _writestrokestyles(self.strokestyles, acontext, registry, bbox)
 298
 299             strokepath.outputPDF(file, writer)
 300             file.write("S\n") # stroke
 301             # take linewidth into account for bbox when stroking a path
 302             bbox += strokepath.bbox().enlarged_pt(0.5*acontext.linewidth_pt)
 303
 304             if self.strokestyles:
 305                 file.write("Q\n") # grestore
 306
 307         # now, draw additional elements of decoratedpath
 308         self.ornaments.processPDF(file, writer, context, registry, bbox)
 309
 310         # restore global styles
 311         if self.styles:
 312             file.write("Q\n") # grestore
 313
 314 #
 315 # Path decorators
 316 #
 317
 318 class deco:
 319
 320     """decorators
 321
 322     In contrast to path styles, path decorators depend on the concrete
 323     path to which they are applied. In particular, they don't make
 324     sense without any path and can thus not be used in canvas.set!
 325
 326     """
 327
 328     def decorate(self, dp, texrunner):
 329         """apply a style to a given decoratedpath object dp
 330
 331         decorate accepts a decoratedpath object dp, applies PathStyle
 332         by modifying dp in place.
 333         """
 334
 335         pass
 336
 337 #
 338 # stroked and filled: basic decos which stroked and fill,
 339 # respectively the path
 340 #
 341
 342 class _stroked(deco, attr.exclusiveattr):
 343
 344     """stroked is a decorator, which draws the outline of the path"""
 345
 346     def __init__(self, styles=[]):
 347         attr.exclusiveattr.__init__(self, _stroked)
 348         self.styles = attr.mergeattrs(styles)
 349         attr.checkattrs(self.styles, [style.strokestyle])
 350
 351     def __call__(self, styles=[]):
 352         # XXX or should we also merge self.styles
 353         return _stroked(styles)
 354
 355     def decorate(self, dp, texrunner):
 356         if dp.strokestyles is not None:
 357             raise RuntimeError("Cannot stroke an already stroked path")
 358         dp.strokestyles = self.styles
 359
 360 stroked = _stroked()
 361 stroked.clear = attr.clearclass(_stroked)
 362
 363
 364 class _filled(deco, attr.exclusiveattr):
 365
 366     """filled is a decorator, which fills the interior of the path"""
 367
 368     def __init__(self, styles=[]):
 369         attr.exclusiveattr.__init__(self, _filled)
 370         self.styles = attr.mergeattrs(styles)
 371         attr.checkattrs(self.styles, [style.fillstyle])
 372
 373     def __call__(self, styles=[]):
 374         # XXX or should we also merge self.styles
 375         return _filled(styles)
 376
 377     def decorate(self, dp, texrunner):
 378         if dp.fillstyles is not None:
 379             raise RuntimeError("Cannot fill an already filled path")
 380         dp.fillstyles = self.styles
 381
 382 filled = _filled()
 383 filled.clear = attr.clearclass(_filled)
 384
 385 #
 386 # Arrows
 387 #
 388
 389 # helper function which constructs the arrowhead
 390
 391 def _arrowhead(anormpath, arclenfrombegin, direction, size, angle, constrictionlen):
 392
 393     """helper routine, which returns an arrowhead from a given anormpath
 394
 395     - arclenfrombegin: position of arrow in arc length from the start of the path
 396     - direction: +1 for an arrow pointing along the direction of anormpath or
 397                  -1 for an arrow pointing opposite to the direction of normpath
 398     - size: size of the arrow as arc length
 399     - angle. opening angle
 400     - constrictionlen: None (no constriction) or arc length of constriction.
 401     """
 402
 403     # arc length and coordinates of tip
 404     tx, ty = anormpath.at(arclenfrombegin)
 405
 406     # construct the template for the arrow by cutting the path at the
 407     # corresponding length
 408     arrowtemplate = anormpath.split([arclenfrombegin, arclenfrombegin - direction * size])[1]
 409
 410     # from this template, we construct the two outer curves of the arrow
 411     arrowl = arrowtemplate.transformed(trafo.rotate(-angle/2.0, tx, ty))
 412     arrowr = arrowtemplate.transformed(trafo.rotate( angle/2.0, tx, ty))
 413
 414     # now come the joining backward parts
 415     if constrictionlen is not None:
 416         # constriction point (cx, cy) lies on path
 417         cx, cy = anormpath.at(arclenfrombegin - direction * constrictionlen)
 418         arrowcr= path.line(*(arrowr.atend() + (cx,cy)))
 419         arrow = arrowl.reversed() << arrowr << arrowcr
 420     else:
 421         arrow = arrowl.reversed() << arrowr
 422
 423     arrow[-1].close()
 424
 425     return arrow
 426
 427
 428 _base = 6 * unit.v_pt
 429
 430 class arrow(deco, attr.attr):
 431
 432     """arrow is a decorator which adds an arrow to either side of the path"""
 433
 434     def __init__(self, attrs=[], pos=1, reversed=0, size=_base, angle=45, constriction=0.8):
 435         self.attrs = attr.mergeattrs([style.linestyle.solid, filled] + attrs)
 436         attr.checkattrs(self.attrs, [deco, style.fillstyle, style.strokestyle])
 437         self.pos = pos
 438         self.reversed = reversed
 439         self.size = size
 440         self.angle = angle
 441         self.constriction = constriction
 442
 443     def __call__(self, attrs=None, pos=None, reversed=None, size=None, angle=None, constriction=_marker):
 444         if attrs is None:
 445             attrs = self.attrs
 446         if pos is None:
 447             pos = self.pos
 448         if reversed is None:
 449             reversed = self.reversed
 450         if size is None:
 451             size = self.size
 452         if angle is None:
 453             angle = self.angle
 454         if constriction is _marker:
 455             constriction = self.constriction
 456         return arrow(attrs=attrs, pos=pos, reversed=reversed, size=size, angle=angle, constriction=constriction)
 457
 458     def decorate(self, dp, texrunner):
 459         dp.ensurenormpath()
 460         anormpath = dp.path
 461
 462         # calculate absolute arc length of constricition
 463         # Note that we have to correct this length because the arrowtemplates are rotated
 464         # by self.angle/2 to the left and right. Hence, if we want no constriction, i.e., for
 465         # self.constriction = 1, we actually have a length which is approximately shorter
 466         # by the given geometrical factor.
 467         if self.constriction is not None:
 468             constrictionlen = arrowheadconstrictionlen = self.size * self.constriction * math.cos(math.radians(self.angle/2.0))
 469         else:
 470             # if we do not want a constriction, i.e. constriction is None, we still
 471             # need constrictionlen for cutting the path
 472             constrictionlen = self.size * 1 * math.cos(math.radians(self.angle/2.0))
 473             arrowheadconstrictionlen = None
 474
 475         arclenfrombegin = (1-self.reversed)*constrictionlen + self.pos * (anormpath.arclen() - constrictionlen)
 476         direction = self.reversed and -1 or 1
 477         arrowhead = _arrowhead(anormpath, arclenfrombegin, direction, self.size, self.angle, arrowheadconstrictionlen)
 478
 479         # add arrowhead to decoratedpath
 480         dp.ornaments.draw(arrowhead, self.attrs)
 481
 482         # exlude part of the path from stroking when the arrow is strictly at the begin or the end
 483         if self.pos == 0 and self.reversed:
 484             dp.excluderange(0, min(self.size, constrictionlen))
 485         elif self.pos == 1 and not self.reversed:
 486             dp.excluderange(anormpath.end() - min(self.size, constrictionlen), anormpath.end())
 487
 488 arrow.clear = attr.clearclass(arrow)
 489
 490 # arrows at begin of path
 491 barrow = arrow(pos=0, reversed=1)
 492 barrow.SMALL = barrow(size=_base/math.sqrt(64))
 493 barrow.SMALl = barrow(size=_base/math.sqrt(32))
 494 barrow.SMAll = barrow(size=_base/math.sqrt(16))
 495 barrow.SMall = barrow(size=_base/math.sqrt(8))
 496 barrow.Small = barrow(size=_base/math.sqrt(4))
 497 barrow.small = barrow(size=_base/math.sqrt(2))
 498 barrow.normal = barrow(size=_base)
 499 barrow.large = barrow(size=_base*math.sqrt(2))
 500 barrow.Large = barrow(size=_base*math.sqrt(4))
 501 barrow.LArge = barrow(size=_base*math.sqrt(8))
 502 barrow.LARge = barrow(size=_base*math.sqrt(16))
 503 barrow.LARGe = barrow(size=_base*math.sqrt(32))
 504 barrow.LARGE = barrow(size=_base*math.sqrt(64))
 505
 506 # arrows at end of path
 507 earrow = arrow()
 508 earrow.SMALL = earrow(size=_base/math.sqrt(64))
 509 earrow.SMALl = earrow(size=_base/math.sqrt(32))
 510 earrow.SMAll = earrow(size=_base/math.sqrt(16))
 511 earrow.SMall = earrow(size=_base/math.sqrt(8))
 512 earrow.Small = earrow(size=_base/math.sqrt(4))
 513 earrow.small = earrow(size=_base/math.sqrt(2))
 514 earrow.normal = earrow(size=_base)
 515 earrow.large = earrow(size=_base*math.sqrt(2))
 516 earrow.Large = earrow(size=_base*math.sqrt(4))
 517 earrow.LArge = earrow(size=_base*math.sqrt(8))
 518 earrow.LARge = earrow(size=_base*math.sqrt(16))
 519 earrow.LARGe = earrow(size=_base*math.sqrt(32))
 520 earrow.LARGE = earrow(size=_base*math.sqrt(64))
 521
 522
 523 class text(deco, attr.attr):
 524     """a simple text decorator"""
 525
 526     def __init__(self, text, textattrs=[], angle=0, relangle=None, textdist=0.2,
 527                        relarclenpos=0.5, arclenfrombegin=None, arclenfromend=None,
 528                        texrunner=None):
 529         if arclenfrombegin is not None and arclenfromend is not None:
 530             raise ValueError("either set arclenfrombegin or arclenfromend")
 531         self.text = text
 532         self.textattrs = textattrs
 533         self.angle = angle
 534         self.relangle = relangle
 535         self.textdist = textdist
 536         self.relarclenpos = relarclenpos
 537         self.arclenfrombegin = arclenfrombegin
 538         self.arclenfromend = arclenfromend
 539         self.texrunner = texrunner
 540
 541     def decorate(self, dp, texrunner):
 542         if self.texrunner:
 543             texrunner = self.texrunner
 544         import text as textmodule
 545         textattrs = attr.mergeattrs([textmodule.halign.center, textmodule.vshift.mathaxis] + self.textattrs)
 546
 547         dp.ensurenormpath()
 548         if self.arclenfrombegin is not None:
 549             param = dp.path.begin() + self.arclenfrombegin
 550         elif self.arclenfromend is not None:
 551             param = dp.path.end() - self.arclenfromend
 552         else:
 553             # relarcpos is used, when neither arcfrombegin nor arcfromend is given
 554             param = self.relarclenpos * dp.path.arclen()
 555         x, y = dp.path.at(param)
 556
 557         if self.relangle is not None:
 558             a = dp.path.trafo(param).apply_pt(math.cos(self.relangle*math.pi/180), math.sin(self.relangle*math.pi/180))
 559             b = dp.path.trafo(param).apply_pt(0, 0)
 560             angle = math.atan2(a[1] - b[1], a[0] - b[0])
 561         else:
 562             angle = self.angle*math.pi/180
 563         t = texrunner.text(x, y, self.text, textattrs)
 564         t.linealign(self.textdist, math.cos(angle), math.sin(angle))
 565         dp.ornaments.insert(t)
 566
 567 class curvedtext(deco, attr.attr):
 568     """a text decorator for curved text
 569
 570     - text: is typeset along the path to which this decorator is applied
 571     - relarclenpos: position for the base point of the text (default: 0)
 572     - arlenfrombegin, arclenfromend: alternative ways of specifying the position of the base point;
 573                                      use of relarclenpos, arclenfrombegin and arclenfromend is mutually exclusive
 574     - textattrs, texrunner: standard text arguments (defaults: [] resp None)
 575
 576     """
 577
 578     def __init__(self, text, textattrs=[],
 579                        relarclenpos=0, arclenfrombegin=None, arclenfromend=None,
 580                        texrunner=None):
 581         if arclenfrombegin is not None and arclenfromend is not None:
 582             raise ValueError("either set arclenfrombegin or arclenfromend")
 583         self.text = text
 584         self.textattrs = textattrs
 585         self.relarclenpos = relarclenpos
 586         self.arclenfrombegin = arclenfrombegin
 587         self.arclenfromend = arclenfromend
 588         self.texrunner = texrunner
 589
 590     def decorate(self, dp, texrunner):
 591         if self.texrunner:
 592             texrunner = self.texrunner
 593         import text as textmodule
 594
 595         dp.ensurenormpath()
 596         if self.arclenfrombegin is not None:
 597             textpos = dp.path.begin() + self.arclenfrombegin
 598         elif self.arclenfromend is not None:
 599             textpos = dp.path.end() - self.arclenfromend
 600         else:
 601             # relarcpos is used if neither arcfrombegin nor arcfromend is given
 602             textpos = self.relarclenpos * dp.path.arclen()
 603
 604         c = canvas.canvas()
 605
 606         t = texrunner.text(0, 0, self.text, self.textattrs, singlecharmode=1)
 607
 608         # copy over attr ops (colour...)
 609         # isinstance(op, canvas._canvas) should not occur before ensuredvicanvas; should we even care to check?
 610         [ c.insert(op) for op in t.items if not isinstance(op, canvas._canvas)]
 611
 612         t.ensuredvicanvas(singlecharmode=1)
 613
 614         items = t.dvicanvas.items
 615         xs = [item.bbox().center()[0] for item in items]
 616         trafos = dp.path.trafo([textpos +x for x in xs])
 617         for x, op, atrafo in zip(xs, items, trafos):
 618             c.insert(op, [trafo.translate(-x, 0), atrafo]) # reversed trafos: fix for change in canvas.py from r2728 to 2730
 619
 620         dp.ornaments.insert(c)
 621
 622
 623
 624 class shownormpath(deco, attr.attr):
 625
 626     def decorate(self, dp, texrunner):
 627         r_pt = 2
 628         dp.ensurenormpath()
 629         for normsubpath in dp.path.normsubpaths:
 630             for i, normsubpathitem in enumerate(normsubpath.normsubpathitems):
 631                 if isinstance(normsubpathitem, normpath.normcurve_pt):
 632                     dp.ornaments.stroke(normpath.normpath([normpath.normsubpath([normsubpathitem])]), [color.rgb.green])
 633                 else:
 634                     dp.ornaments.stroke(normpath.normpath([normpath.normsubpath([normsubpathitem])]), [color.rgb.blue])
 635         for normsubpath in dp.path.normsubpaths:
 636             for i, normsubpathitem in enumerate(normsubpath.normsubpathitems):
 637                 if isinstance(normsubpathitem, normpath.normcurve_pt):
 638                     dp.ornaments.stroke(path.line_pt(normsubpathitem.x0_pt, normsubpathitem.y0_pt, normsubpathitem.x1_pt, normsubpathitem.y1_pt), [style.linestyle.dashed, color.rgb.red])
 639                     dp.ornaments.stroke(path.line_pt(normsubpathitem.x2_pt, normsubpathitem.y2_pt, normsubpathitem.x3_pt, normsubpathitem.y3_pt), [style.linestyle.dashed, color.rgb.red])
 640                     dp.ornaments.draw(path.circle_pt(normsubpathitem.x1_pt, normsubpathitem.y1_pt, r_pt), [filled([color.rgb.red])])
 641                     dp.ornaments.draw(path.circle_pt(normsubpathitem.x2_pt, normsubpathitem.y2_pt, r_pt), [filled([color.rgb.red])])
 642         for normsubpath in dp.path.normsubpaths:
 643             for i, normsubpathitem in enumerate(normsubpath.normsubpathitems):
 644                 if not i:
 645                     x_pt, y_pt = normsubpathitem.atbegin_pt()
 646                     dp.ornaments.draw(path.circle_pt(x_pt, y_pt, r_pt), [filled])
 647                 x_pt, y_pt = normsubpathitem.atend_pt()
 648                 dp.ornaments.draw(path.circle_pt(x_pt, y_pt, r_pt), [filled])
 649
 650
 651 class linehatched(deco, attr.clearclass):
 652     """draws a pattern with explicit lines
 653
 654     This class acts as a drop-in replacement for postscript patterns
 655     from the pattern module which are not understood by some printers"""
 656
 657     def __init__(self, dist, angle, shift=0, strokestyles=[], center=None):
 658         attr.clearclass.__init__(self, _filled)
 659         self.dist = dist
 660         self.angle = angle
 661         self.strokestyles = attr.mergeattrs([style.linewidth.THIN] + strokestyles)
 662         attr.checkattrs(self.strokestyles, [style.strokestyle])
 663         self.center = center
 664         self.shift = shift
 665
 666     def __call__(self, dist=None, angle=None, shift=None, strokestyles=None, center=_marker):
 667         if dist is None:
 668             dist = self.dist
 669         if angle is None:
 670             angle = self.angle
 671         if shift is None:
 672             shift = self.shift
 673         if strokestyles is None:
 674             strokestyles = self.strokestyles
 675         if center is _marker:
 676             center = self.center
 677         return linehatched(dist, angle, shift, strokestyles, center)
 678
 679     def _decocanvas(self, angle, dp, texrunner):
 680         dp.ensurenormpath()
 681         dist_pt = unit.topt(self.dist)
 682         shift_pt = unit.topt(self.shift)
 683
 684         c = canvas.canvas([canvas.clip(dp.path)])
 685         llx_pt, lly_pt, urx_pt, ury_pt = dp.path.bbox().highrestuple_pt()
 686         if self.center is None:
 687             center_pt = 0.5*(llx_pt+urx_pt), 0.5*(lly_pt+ury_pt)
 688             radius_pt = 0.5*math.hypot(urx_pt-llx_pt, ury_pt-lly_pt) + dist_pt
 689         else:
 690             center_pt = (unit.topt(self.center[0]), unit.topt(self.center[1]))
 691             radius_pt = dist_pt + max([math.hypot(urx_pt-center_pt[0], ury_pt-center_pt[1]),
 692                                        math.hypot(llx_pt-center_pt[0], lly_pt-center_pt[1]),
 693                                        math.hypot(urx_pt-center_pt[0], lly_pt-center_pt[1]),
 694                                        math.hypot(llx_pt-center_pt[0], ury_pt-center_pt[1])])
 695         n = int(radius_pt / dist_pt)
 696         for i in range(-n-1, n+2):
 697             x_pt = center_pt[0] + i*dist_pt
 698             c.stroke(path.line_pt(x_pt+shift_pt, center_pt[1]-radius_pt, x_pt+shift_pt, center_pt[1]+radius_pt),
 699                      [trafo.rotate_pt(angle, center_pt[0], center_pt[1])] + self.strokestyles)
 700         return c
 701
 702     def decorate(self, dp, texrunner):
 703         dp.ornaments.insert(self._decocanvas(self.angle, dp, texrunner))
 704
 705     def merge(self, attrs):
 706         newattrs = attr.clearclass.merge(self, attrs)
 707         newattrs.append(self)
 708         return newattrs
 709
 710 linehatched.clear = attr.clearclass(linehatched)
 711
 712 _hatch_base = 0.1 * unit.v_cm
 713
 714 linehatched0 = linehatched(_hatch_base, 0)
 715 linehatched0.SMALL = linehatched0(_hatch_base/math.sqrt(64))
 716 linehatched0.SMALL = linehatched0(_hatch_base/math.sqrt(64))
 717 linehatched0.SMALl = linehatched0(_hatch_base/math.sqrt(32))
 718 linehatched0.SMAll = linehatched0(_hatch_base/math.sqrt(16))
 719 linehatched0.SMall = linehatched0(_hatch_base/math.sqrt(8))
 720 linehatched0.Small = linehatched0(_hatch_base/math.sqrt(4))
 721 linehatched0.small = linehatched0(_hatch_base/math.sqrt(2))
 722 linehatched0.normal = linehatched0(_hatch_base)
 723 linehatched0.large = linehatched0(_hatch_base*math.sqrt(2))
 724 linehatched0.Large = linehatched0(_hatch_base*math.sqrt(4))
 725 linehatched0.LArge = linehatched0(_hatch_base*math.sqrt(8))
 726 linehatched0.LARge = linehatched0(_hatch_base*math.sqrt(16))
 727 linehatched0.LARGe = linehatched0(_hatch_base*math.sqrt(32))
 728 linehatched0.LARGE = linehatched0(_hatch_base*math.sqrt(64))
 729
 730 linehatched45 = linehatched(_hatch_base, 45)
 731 linehatched45.SMALL = linehatched45(_hatch_base/math.sqrt(64))
 732 linehatched45.SMALl = linehatched45(_hatch_base/math.sqrt(32))
 733 linehatched45.SMAll = linehatched45(_hatch_base/math.sqrt(16))
 734 linehatched45.SMall = linehatched45(_hatch_base/math.sqrt(8))
 735 linehatched45.Small = linehatched45(_hatch_base/math.sqrt(4))
 736 linehatched45.small = linehatched45(_hatch_base/math.sqrt(2))
 737 linehatched45.normal = linehatched45(_hatch_base)
 738 linehatched45.large = linehatched45(_hatch_base*math.sqrt(2))
 739 linehatched45.Large = linehatched45(_hatch_base*math.sqrt(4))
 740 linehatched45.LArge = linehatched45(_hatch_base*math.sqrt(8))
 741 linehatched45.LARge = linehatched45(_hatch_base*math.sqrt(16))
 742 linehatched45.LARGe = linehatched45(_hatch_base*math.sqrt(32))
 743 linehatched45.LARGE = linehatched45(_hatch_base*math.sqrt(64))
 744
 745 linehatched90 = linehatched(_hatch_base, 90)
 746 linehatched90.SMALL = linehatched90(_hatch_base/math.sqrt(64))
 747 linehatched90.SMALl = linehatched90(_hatch_base/math.sqrt(32))
 748 linehatched90.SMAll = linehatched90(_hatch_base/math.sqrt(16))
 749 linehatched90.SMall = linehatched90(_hatch_base/math.sqrt(8))
 750 linehatched90.Small = linehatched90(_hatch_base/math.sqrt(4))
 751 linehatched90.small = linehatched90(_hatch_base/math.sqrt(2))
 752 linehatched90.normal = linehatched90(_hatch_base)
 753 linehatched90.large = linehatched90(_hatch_base*math.sqrt(2))
 754 linehatched90.Large = linehatched90(_hatch_base*math.sqrt(4))
 755 linehatched90.LArge = linehatched90(_hatch_base*math.sqrt(8))
 756 linehatched90.LARge = linehatched90(_hatch_base*math.sqrt(16))
 757 linehatched90.LARGe = linehatched90(_hatch_base*math.sqrt(32))
 758 linehatched90.LARGE = linehatched90(_hatch_base*math.sqrt(64))
 759
 760 linehatched135 = linehatched(_hatch_base, 135)
 761 linehatched135.SMALL = linehatched135(_hatch_base/math.sqrt(64))
 762 linehatched135.SMALl = linehatched135(_hatch_base/math.sqrt(32))
 763 linehatched135.SMAll = linehatched135(_hatch_base/math.sqrt(16))
 764 linehatched135.SMall = linehatched135(_hatch_base/math.sqrt(8))
 765 linehatched135.Small = linehatched135(_hatch_base/math.sqrt(4))
 766 linehatched135.small = linehatched135(_hatch_base/math.sqrt(2))
 767 linehatched135.normal = linehatched135(_hatch_base)
 768 linehatched135.large = linehatched135(_hatch_base*math.sqrt(2))
 769 linehatched135.Large = linehatched135(_hatch_base*math.sqrt(4))
 770 linehatched135.LArge = linehatched135(_hatch_base*math.sqrt(8))
 771 linehatched135.LARge = linehatched135(_hatch_base*math.sqrt(16))
 772 linehatched135.LARGe = linehatched135(_hatch_base*math.sqrt(32))
 773 linehatched135.LARGE = linehatched135(_hatch_base*math.sqrt(64))
 774
 775
 776 class colorgradient(deco, attr.attr):
 777     """inserts pieces of the path in different colors"""
 778
 779     def __init__(self, grad, attrs=[], steps=20):
 780         self.attrs = attrs
 781         self.grad = grad
 782         self.steps = steps
 783
 784     def decorate(self, dp, texrunner):
 785         dp.ensurenormpath()
 786         l = dp.path.arclen()
 787
 788         colors = [self.grad.select(n, self.steps) for n in range(self.steps)]
 789         colors.reverse()
 790         params = dp.path.arclentoparam([l*i/float(self.steps) for i in range(self.steps)])
 791         params.reverse()
 792
 793         c = canvas.canvas()
 794         # treat the end pieces separately
 795         c.stroke(dp.path.split(params[1])[1], attr.mergeattrs([colors[0]] + self.attrs))
 796         for n in range(1,self.steps-1):
 797             c.stroke(dp.path.split([params[n-1],params[n+1]])[1], attr.mergeattrs([colors[n]] + self.attrs))
 798         c.stroke(dp.path.split(params[-2])[0], attr.mergeattrs([colors[-1]] + self.attrs))
 799         dp.ornaments.insert(c)
 800
 801
 802 class brace(deco, attr.attr):
 803     r"""draws a nicely curled brace
 804
 805     In most cases, the original line is not wanted use canvas.canvas.draw(..) for it
 806
 807     Geometrical parameters:
 808
 809                  inner /\ strokes
 810           ____________/  \__________
 811          /   bar            bar     \ outer
 812         /                            \ strokes
 813
 814     totalheight  distance from the jaws to the middle cap
 815     barthickness  thickness of the main bars
 816     innerstrokesthickness  thickness of the two ending strokes
 817     outerstrokesthickness  thickness of the inner strokes at the middle cap
 818     innerstrokesrelheight  height of the inner/outer strokes, relative to the total height
 819     outerstrokesrelheight  this determines the angle of the main bars!
 820                            should be around 0.5
 821     Note: if innerstrokesrelheight + outerstrokesrelheight == 1 then the main bars
 822           will be aligned parallel to the connecting line between the endpoints
 823     outerstrokesangle  angle of the two ending strokes
 824     innerstrokesangle  angle between the inner strokes at the middle cap
 825     slantstrokesangle  extra slanting of the inner/outer strokes
 826     innerstrokessmoothness  smoothing parameter for the inner + outer strokes
 827     outerstrokessmoothness  should be around 1 (allowed: [0,infty))
 828     middlerelpos  position of the middle cap (0 == left, 1 == right)
 829     """
 830     # This code is experimental because it is unclear
 831     # how the brace fits into the concepts of PyX
 832     #
 833     # Some thoughts:
 834     # - a brace needs to be decoratable with text
 835     #   it needs stroking and filling attributes
 836     # - the brace is not really a box:
 837     #   it has two "anchor" points that are important for aligning it to other things
 838     #   and one "anchor" point (plus direction) for aligning other things
 839     # - a brace is not a deformer:
 840     #   it does not look at anything else than begin/endpoint of a path
 841     # - a brace might be a connector (which is to be dissolved into the box concept later?)
 842
 843     def __init__(self, reverse=1, stretch=None, dist=None, fillattrs=[],
 844         totalheight=12*unit.x_pt,
 845         barthickness=0.5*unit.x_pt, innerstrokesthickness=0.25*unit.x_pt, outerstrokesthickness=0.25*unit.x_pt,
 846         innerstrokesrelheight=0.6, outerstrokesrelheight=0.7,
 847         innerstrokesangle=30, outerstrokesangle=25, slantstrokesangle=5,
 848         innerstrokessmoothness=2.0, outerstrokessmoothness=2.5,
 849         middlerelpos=0.5):
 850         self.fillattrs = fillattrs
 851         self.reverse = reverse
 852         self.stretch = stretch
 853         self.dist = dist
 854         self.totalheight            = totalheight
 855         self.barthickness           = barthickness
 856         self.innerstrokesthickness  = innerstrokesthickness
 857         self.outerstrokesthickness  = outerstrokesthickness
 858         self.innerstrokesrelheight  = innerstrokesrelheight
 859         self.outerstrokesrelheight  = outerstrokesrelheight
 860         self.innerstrokesangle      = innerstrokesangle
 861         self.outerstrokesangle      = outerstrokesangle
 862         self.slantstrokesangle      = slantstrokesangle
 863         self.innerstrokessmoothness = innerstrokessmoothness
 864         self.outerstrokessmoothness = outerstrokessmoothness
 865         self.middlerelpos           = middlerelpos
 866
 867     def __call__(self, **kwargs):
 868         for name in ["reverse", "stretch", "dist", "fillattrs",
 869             "totalheight", "barthickness", "innerstrokesthickness", "outerstrokesthickness",
 870             "innerstrokesrelheight", "outerstrokesrelheight", "innerstrokesangle", "outerstrokesangle", "slantstrokesangle",
 871             "innerstrokessmoothness", "outerstrokessmoothness", "middlerelpos"]:
 872             if not kwargs.has_key(name):
 873                 kwargs[name] = self.__dict__[name]
 874         return brace(**kwargs)
 875
 876     def _halfbracepath_pt(self, length_pt, height_pt, ilength_pt, olength_pt, # <<<
 877     ithick_pt, othick_pt, bthick_pt, cos_iangle, sin_iangle, cos_oangle,
 878     sin_oangle, cos_slangle, sin_slangle):
 879
 880         ismooth = self.innerstrokessmoothness
 881         osmooth = self.outerstrokessmoothness
 882
 883         # these two parameters are not important enough to be seen outside
 884         inner_cap_param = 1.5
 885         outer_cap_param = 2.5
 886         outerextracurved = 0.6 # in (0, 1]
 887         # 1.0 will lead to F=G, the outer strokes will not be curved at their ends.
 888         # The smaller, the more curvature
 889
 890         # build an orientation path (three straight lines)
 891         #
 892         #      \q1
 893         #    /  \
 894         #   /    \
 895         # _/      \______________________________________q5
 896         #         q2         q3              q4           \
 897         #                                                  \
 898         #                                                   \
 899         #                                                    \q6
 900         #
 901         # get the points for that:
 902         q1 = (0, height_pt - inner_cap_param * ithick_pt + 0.5*ithick_pt/sin_iangle)
 903         q2 = (q1[0] + ilength_pt * sin_iangle,
 904               q1[1] - ilength_pt * cos_iangle)
 905         q6 = (length_pt, 0)
 906         q5 = (q6[0] - olength_pt * sin_oangle,
 907               q6[1] + olength_pt * cos_oangle)
 908         bardir = (q5[0] - q2[0], q5[1] - q2[1])
 909         bardirnorm = math.hypot(*bardir)
 910         bardir = (bardir[0]/bardirnorm, bardir[1]/bardirnorm)
 911         ismoothlength_pt = ilength_pt * ismooth
 912         osmoothlength_pt = olength_pt * osmooth
 913         if bardirnorm < ismoothlength_pt + osmoothlength_pt:
 914             ismoothlength_pt = bardirnorm * ismoothlength_pt / (ismoothlength_pt + osmoothlength_pt)
 915             osmoothlength_pt = bardirnorm * osmoothlength_pt / (ismoothlength_pt + osmoothlength_pt)
 916         q3 = (q2[0] + ismoothlength_pt * bardir[0],
 917               q2[1] + ismoothlength_pt * bardir[1])
 918         q4 = (q5[0] - osmoothlength_pt * bardir[0],
 919               q5[1] - osmoothlength_pt * bardir[1])
 920
 921         #
 922         #    P _O
 923         #   / | \A2
 924         #  / A1\ \
 925         #   /   \ B2C2________D2___________E2_______F2___G2
 926         #        \______________________________________  \
 927         #       B1,C1         D1           E1      F1  G1  \
 928         #                                                \  \
 929         #                                                 \  \H2
 930         #                                                H1\_/I2
 931         #                                                  I1
 932         #
 933         # the halfbraces meet in P and A1:
 934         P = (0, height_pt)
 935         A1 = (0, height_pt - inner_cap_param * ithick_pt)
 936         # A2 is A1, shifted by the inner thickness
 937         A2 = (A1[0] + ithick_pt * cos_iangle,
 938               A1[1] + ithick_pt * sin_iangle)
 939         s, t = deformer.intersection(P, A2, (cos_slangle, sin_slangle), (sin_iangle, -cos_iangle))
 940         O = (P[0] + s * cos_slangle,
 941              P[1] + s * sin_slangle)
 942
 943         # from D1 to E1 is the straight part of the brace
 944         # also back from E2 to D1
 945         D1 = (q3[0] + bthick_pt * bardir[1],
 946               q3[1] - bthick_pt * bardir[0])
 947         D2 = (q3[0] - bthick_pt * bardir[1],
 948               q3[1] + bthick_pt * bardir[0])
 949         E1 = (q4[0] + bthick_pt * bardir[1],
 950               q4[1] - bthick_pt * bardir[0])
 951         E2 = (q4[0] - bthick_pt * bardir[1],
 952               q4[1] + bthick_pt * bardir[0])
 953         # I1, I2 are the control points at the outer stroke
 954         I1 = (q6[0] - 0.5 * othick_pt * cos_oangle,
 955               q6[1] - 0.5 * othick_pt * sin_oangle)
 956         I2 = (q6[0] + 0.5 * othick_pt * cos_oangle,
 957               q6[1] + 0.5 * othick_pt * sin_oangle)
 958         # get the control points for the curved parts of the brace
 959         s, t = deformer.intersection(A1, D1, (sin_iangle, -cos_iangle), bardir)
 960         B1 = (D1[0] + t * bardir[0],
 961               D1[1] + t * bardir[1])
 962         s, t = deformer.intersection(A2, D2, (sin_iangle, -cos_iangle), bardir)
 963         B2 = (D2[0] + t * bardir[0],
 964               D2[1] + t * bardir[1])
 965         s, t = deformer.intersection(E1, I1, bardir, (-sin_oangle, cos_oangle))
 966         G1 = (E1[0] + s * bardir[0],
 967               E1[1] + s * bardir[1])
 968         s, t = deformer.intersection(E2, I2, bardir, (-sin_oangle, cos_oangle))
 969         G2 = (E2[0] + s * bardir[0],
 970               E2[1] + s * bardir[1])
 971         # at the inner strokes: use curvature zero at both ends
 972         C1 = B1
 973         C2 = B2
 974         # at the outer strokes: use curvature zero only at the connection to
 975         # the straight part
 976         F1 = (outerextracurved * G1[0] + (1 - outerextracurved) * E1[0],
 977               outerextracurved * G1[1] + (1 - outerextracurved) * E1[1])
 978         F2 = (outerextracurved * G2[0] + (1 - outerextracurved) * E2[0],
 979               outerextracurved * G2[1] + (1 - outerextracurved) * E2[1])
 980         # the tip of the outer stroke, endpoints of the bezier curve
 981         H1 = (I1[0] - outer_cap_param * othick_pt * sin_oangle,
 982               I1[1] + outer_cap_param * othick_pt * cos_oangle)
 983         H2 = (I2[0] - outer_cap_param * othick_pt * sin_oangle,
 984               I2[1] + outer_cap_param * othick_pt * cos_oangle)
 985
 986         #for qq in [A1,B1,C1,D1,E1,F1,G1,H1,I1,
 987         #           A2,B2,C2,D2,E2,F2,G2,H2,I2,
 988         #           O,P
 989         #           ]:
 990         #    cc.fill(path.circle(qq[0], qq[1], 0.5), [color.rgb.green])
 991
 992         # now build the right halfbrace
 993         bracepath = path.path(path.moveto_pt(*A1))
 994         bracepath.append(path.curveto_pt(B1[0], B1[1], C1[0], C1[1], D1[0], D1[1]))
 995         bracepath.append(path.lineto_pt(E1[0], E1[1]))
 996         bracepath.append(path.curveto_pt(F1[0], F1[1], G1[0], G1[1], H1[0], H1[1]))
 997         # the tip of the right halfbrace
 998         bracepath.append(path.curveto_pt(I1[0], I1[1], I2[0], I2[1], H2[0], H2[1]))
 999         # the rest of the right halfbrace
1000         bracepath.append(path.curveto_pt(G2[0], G2[1], F2[0], F2[1], E2[0], E2[1]))
1001         bracepath.append(path.lineto_pt(D2[0], D2[1]))
1002         bracepath.append(path.curveto_pt(C2[0], C2[1], B2[0], B2[1], A2[0], A2[1]))
1003         # the tip in the middle of the brace
1004         bracepath.append(path.curveto_pt(O[0], O[1], O[0], O[1], P[0], P[1]))
1005
1006         return bracepath
1007     # >>>
1008
1009     def _bracepath(self, x0_pt, y0_pt, x1_pt, y1_pt): # <<<
1010         height_pt = unit.topt(self.totalheight)
1011         totallength_pt = math.hypot(x1_pt - x0_pt, y1_pt - y0_pt)
1012         leftlength_pt = self.middlerelpos * totallength_pt
1013         rightlength_pt = totallength_pt - leftlength_pt
1014         ithick_pt = unit.topt(self.innerstrokesthickness)
1015         othick_pt = unit.topt(self.outerstrokesthickness)
1016         bthick_pt = unit.topt(self.barthickness)
1017
1018         # create the left halfbrace with positive slanting
1019         # because we will mirror this part
1020         cos_iangle = math.cos(math.radians(0.5*self.innerstrokesangle - self.slantstrokesangle))
1021         sin_iangle = math.sin(math.radians(0.5*self.innerstrokesangle - self.slantstrokesangle))
1022         cos_oangle = math.cos(math.radians(self.outerstrokesangle - self.slantstrokesangle))
1023         sin_oangle = math.sin(math.radians(self.outerstrokesangle - self.slantstrokesangle))
1024         cos_slangle = math.cos(math.radians(-self.slantstrokesangle))
1025         sin_slangle = math.sin(math.radians(-self.slantstrokesangle))
1026         ilength_pt = self.innerstrokesrelheight * height_pt / cos_iangle
1027         olength_pt = self.outerstrokesrelheight * height_pt / cos_oangle
1028
1029         bracepath = self._halfbracepath_pt(leftlength_pt, height_pt,
1030           ilength_pt, olength_pt, ithick_pt, othick_pt, bthick_pt, cos_iangle,
1031           sin_iangle, cos_oangle, sin_oangle, cos_slangle,
1032           sin_slangle).reversed().transformed(trafo.mirror(90))
1033
1034         # create the right halfbrace with negative slanting
1035         cos_iangle = math.cos(math.radians(0.5*self.innerstrokesangle + self.slantstrokesangle))
1036         sin_iangle = math.sin(math.radians(0.5*self.innerstrokesangle + self.slantstrokesangle))
1037         cos_oangle = math.cos(math.radians(self.outerstrokesangle + self.slantstrokesangle))
1038         sin_oangle = math.sin(math.radians(self.outerstrokesangle + self.slantstrokesangle))
1039         cos_slangle = math.cos(math.radians(-self.slantstrokesangle))
1040         sin_slangle = math.sin(math.radians(-self.slantstrokesangle))
1041         ilength_pt = self.innerstrokesrelheight * height_pt / cos_iangle
1042         olength_pt = self.outerstrokesrelheight * height_pt / cos_oangle
1043
1044         bracepath = bracepath << self._halfbracepath_pt(rightlength_pt, height_pt,
1045         ilength_pt, olength_pt, ithick_pt, othick_pt, bthick_pt, cos_iangle,
1046         sin_iangle, cos_oangle, sin_oangle, cos_slangle,
1047         sin_slangle)
1048
1049         return bracepath.transformed(
1050           # two trafos for matching the given endpoints
1051           trafo.translate_pt(x0_pt, y0_pt) *
1052           trafo.rotate_pt(math.degrees(math.atan2(y1_pt-y0_pt, x1_pt-x0_pt))) *
1053           # one trafo to move the brace's left outer stroke to zero
1054           trafo.translate_pt(leftlength_pt, 0))
1055     # >>>
1056
1057     def decorate(self, dp, texrunner):
1058         dp.ensurenormpath()
1059         x0_pt, y0_pt = dp.path.atbegin_pt()
1060         x1_pt, y1_pt = dp.path.atend_pt()
1061         if self.reverse:
1062             x0_pt, y0_pt, x1_pt, y1_pt = x1_pt, y1_pt, x0_pt, y0_pt
1063         if self.stretch is not None:
1064             xm, ym = 0.5*(x0_pt+x1_pt), 0.5*(y0_pt+y1_pt)
1065             x0_pt, y0_pt = xm + self.stretch*(x0_pt-xm), ym + self.stretch*(y0_pt-ym)
1066             x1_pt, y1_pt = xm + self.stretch*(x1_pt-xm), ym + self.stretch*(y1_pt-ym)
1067         if self.dist is not None:
1068             d = unit.topt(self.dist)
1069             dx, dy = dp.path.rotation_pt(dp.path.begin()).apply_pt(0, 1)
1070             x0_pt += d*dx; y0_pt += d*dy
1071             dx, dy = dp.path.rotation_pt(dp.path.end()).apply_pt(0, 1)
1072             x1_pt += d*dx; y1_pt += d*dy
1073         dp.ornaments.fill(self._bracepath(x0_pt, y0_pt, x1_pt, y1_pt), self.fillattrs)
1074
1075 brace.clear = attr.clearclass(brace)
1076
1077 leftbrace  = brace(reverse=0, middlerelpos=0.55, innerstrokesrelheight=0.6, outerstrokesrelheight=0.7, slantstrokesangle=-10)
1078 rightbrace = brace(reverse=1, middlerelpos=0.45, innerstrokesrelheight=0.6, outerstrokesrelheight=0.7, slantstrokesangle=10)
1079 belowbrace = brace(reverse=1, middlerelpos=0.55, innerstrokesrelheight=0.7, outerstrokesrelheight=0.9, slantstrokesangle=-10)
1080 abovebrace = brace(reverse=0, middlerelpos=0.45, innerstrokesrelheight=0.7, outerstrokesrelheight=0.9, slantstrokesangle=-10)
1081 straightbrace = brace(innerstrokesrelheight=0.5, outerstrokesrelheight=0.5,
1082         innerstrokesangle=30, outerstrokesangle=30, slantstrokesangle=0,
1083         innerstrokessmoothness=1.0, outerstrokessmoothness=1.0)
1084