# # Copyright (c) 2003, 2004, 2005, 2006 Art Haas # # This file is part of PythonCAD. # # PythonCAD is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # PythonCAD is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with PythonCAD; if not, write to the Free Software # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA # # # classes for leader lines # from __future__ import generators import math import array from PythonCAD.Generic import graphicobject from PythonCAD.Generic import tolerance from PythonCAD.Generic import style from PythonCAD.Generic import linetype from PythonCAD.Generic import color from PythonCAD.Generic import point from PythonCAD.Generic import util from PythonCAD.Generic import quadtree class Leader(graphicobject.GraphicObject): """A class representing a leader line. A leader line is usually used as a visual connector between some text and an entity in a drawing. Leader lines cannot be used to define an edge of some shape. A Leader object has the following attributes: p1: A Point object representing the first end point. p2: A Point object representing the leader mid point. p3: A Point object representing the final end point. arrowsize: The size of the arrow at the end of the leader line A Leader object has the following methods: getPoints(): Return the points defining the Leader {get/set}P1(): Get/Set the Leader first endpoint. {get/set}P2(): Get/Set the Leader midpoint {get/set}P3(): Get/Set the Leader final endpoint {get/set}ArrowSize(): Get/Set the Leader line arrow size. calcArrowPoints(): Calculate where the Leader arrow points are. getArrowPoints(): Return where the Leader arrow points are. move(): Move the Leader. mapCoords(): See if a point lies within some distance of a Leader. inRegion(): Test if the Leader is visible in some area. clone(): Make an identical copy of a Leader. """ __defstyle = None __messages = { 'moved' : True, 'point_changed' : True, 'size_changed' : True, } def __init__(self, p1, p2, p3, size=1.0, st=None, lt=None, col=None, th=None, **kw): """Initialize a Leader object. Leader(p1, p2, p3[, size, st, lt, col, th]) The following arguments are required: p1: Leader first endpoint - may be a Point or a two-item tuple of floats p2: Leader mid point - may be a Point or a two-item tuple of floats p3: Leader final endpoint - may be a Point or a two-item tuple of floats Argument size is optional. It gives the size of the arrow at the end of the leader line, and defaults to 1.0. """ _p1 = p1 if not isinstance(_p1, point.Point): _p1 = point.Point(p1) _p2 = p2 if not isinstance(_p2, point.Point): _p2 = point.Point(p2) if _p1 is _p2: raise ValueError, "Leader points p1 and p2 cannot be identical." _p3 = p3 if not isinstance(_p3, point.Point): _p3 = point.Point(_p3) if _p1 is _p3: raise ValueError, "Leader points p1 and p3 cannot be identical." if _p2 is _p3: raise ValueError, "Leader points p2 and p3 cannot be identical" _size = util.get_float(size) if _size < 0.0: raise ValueError, "Invalid arrow size: %g" % _size _st = st if _st is None: _st = self.getDefaultStyle() super(Leader, self).__init__(_st, lt, col, th, **kw) self.__p1 = _p1 _p1.connect('moved', self.__movePoint) _p1.connect('change_pending', self.__pointChangePending) _p1.connect('change_complete', self.__pointChangeComplete) _p1.storeUser(self) self.__p2 = _p2 _p2.connect('moved', self.__movePoint) _p2.connect('change_pending', self.__pointChangePending) _p2.connect('change_complete', self.__pointChangeComplete) _p2.storeUser(self) self.__p3 = _p3 _p3.connect('moved', self.__movePoint) _p3.connect('change_pending', self.__pointChangePending) _p3.connect('change_complete', self.__pointChangeComplete) _p3.storeUser(self) self.__size = _size self.__arrow_pts = array.array('d', [0.0, 0.0, 0.0, 0.0]) self.calcArrowPoints() def __str__(self): return "Leader: %s to %s to %s" % (self.__p1, self.__p2, self.__p3) def __eq__(self, obj): """Compare two leader lines for equality. """ if not isinstance(obj, Leader): return False if obj is self: return True _sp1 = self.__p1 _sp2 = self.__p2 _sp3 = self.__p3 _p1, _p2, _p3 = obj.getPoints() if (_sp1 == _p1 and _sp2 == _p2 and _sp3 == _p3): return True return False def __ne__(self, obj): """Compare two leader lines for inequality. """ if not isinstance(obj, Leader): return True if obj is self: return False _sp1 = self.__p1 _sp2 = self.__p2 _sp3 = self.__p3 _p1, _p2, _p3 = obj.getPoints() if (_sp1 == _p1 and _sp2 == _p2 and _sp3 == _p3): return False return True def getDefaultStyle(cls): if cls.__defstyle is None: _s = style.Style(u'Leader Default Style', linetype.Linetype(u'Solid', None), color.Color(0xffffff), 1.0) cls.__defstyle = _s return cls.__defstyle getDefaultStyle = classmethod(getDefaultStyle) def setDefaultStyle(cls, s): if not isinstance(s, style.Style): raise TypeError, "Invalid style: " + `type(s)` cls.__defstyle = s setDefaultStyle = classmethod(setDefaultStyle) def finish(self): self.__p1.disconnect(self) self.__p1.freeUser(self) self.__p2.disconnect(self) self.__p2.freeUser(self) self.__p3.disconnect(self) self.__p3.freeUser(self) self.__p1 = self.__p2 = self.__p3 = self.__size = None super(Leader, self).finish() def setStyle(self, s): """Set the Style of the Leader. setStyle(s) This method extends GraphicObject::setStyle(). """ _s = s if _s is None: _s = self.getDefaultStyle() super(Leader, self).setStyle(_s) def getValues(self): """Return values comprising the Arc. getValues() This method extends the GraphicObject::getValues() method. """ _data = super(Leader, self).getValues() _data.setValue('type', 'leader') _data.setValue('p1', self.__p1.getID()) _data.setValue('p2', self.__p2.getID()) _data.setValue('p3', self.__p3.getID()) _data.setValue('size', self.__size) return _data def getPoints(self): """Get the points defining the Leader. getPoints() This function returns a tuple containing the three Point objects that are the defining points of the Leader """ return self.__p1, self.__p2, self.__p3 def getP1(self): """Return the first endpoint Point of the Leader getP1() """ return self.__p1 def setP1(self, p): """Set the first endpoint Point of the Leader setP1(p) The argument 'p' should be a Point. """ if self.isLocked(): raise RuntimeError, "Setting points not allowed - object locked." if not isinstance(p, point.Point): raise TypeError, "Invalid P1 point: " + `type(p)` if p is self.__p2 or p is self.__p3: raise ValueError, "Leader points cannot be identical." _pt = self.__p1 if _pt is not p: _pt.disconnect(self) _pt.freeUser(self) self.startChange('point_changed') self.__p1 = p self.endChange('point_changed') self.sendMessage('point_changed', _pt, p) p.storeUser(self) p.connect('moved', self.__movePoint) p.connect('change_pending', self.__pointChangePending) p.connect('change_complete', self.__pointChangeComplete) if abs(_pt.x - p.x) > 1e-10 or abs(_pt.y - p.y) > 1e-10: _x2, _y2 = self.__p2.getCoords() _x3, _y3 = self.__p3.getCoords() self.sendMessage('moved', _pt.x, _pt.y, _x2, _y2, _x3, _y3) self.modified() p1 = property(getP1, setP1, None, "First endpoint of the Leader.") def getP2(self): """Return the midpoint Point of the Leader. getP2() """ return self.__p2 def setP2(self, p): """Set the midpoint Point of the Leader. setP2(p) The argument 'p' should be a Point. """ if self.isLocked(): raise RuntimeError, "Setting points not allowed - object locked." if not isinstance(p, point.Point): raise TypeError, "Invalid P2 point: " + `type(p)` if p is self.__p1 or p is self.__p3: raise ValueError, "Leader points cannot be identical." _pt = self.__p2 if _pt is not p: _pt.disconnect(self) _pt.freeUser(self) self.startChange('point_changed') self.__p2 = p self.endChange('point_changed') self.sendMessage('point_changed', _pt, p) p.storeUser(self) p.connect('moved', self.__movePoint) p.connect('change_pending', self.__pointChangePending) p.connect('change_complete', self.__pointChangeComplete) if abs(_pt.x - p.x) > 1e-10 or abs(_pt.y - p.y) > 1e-10: self.calcArrowPoints() _x1, _y1 = self.__p1.getCoords() _x3, _y3 = self.__p3.getCoords() self.sendMessage('moved', _x1, _y1, _pt.x, _pt.y, _x3, _y3) self.modified() p2 = property(getP2, setP2, None, "Leader midpoint.") def getP3(self): """Return the final Point of the Leader. getP3() """ return self.__p3 def setP3(self, p): """Set the final endpoint Point of the Leader. setP3(p) The argument 'p' should be a Point. """ if not isinstance(p, point.Point): raise TypeError, "Invalid Point for p3 endpoint: " + `p` if self.isLocked(): raise RuntimeError, "Setting points not allowed - object locked." if not isinstance(p, point.Point): raise TypeError, "Invalid P3 point: " + `type(p)` if p is self.__p1 or p is self.__p2: raise ValueError, "Leader points cannot be identical." _pt = self.__p3 if _pt is not p: _pt.disconnect(self) _pt.freeUser(self) self.startChange('point_changed') self.__p3 = p self.endChange('point_changed') self.sendMessage('point_changed', _pt, p) p.storeUser(self) p.connect('moved', self.__movePoint) p.connect('change_pending', self.__pointChangePending) p.connect('change_complete', self.__pointChangeComplete) if abs(_pt.x - p.x) > 1e-10 or abs(_pt.y - p.y) > 1e-10: self.calcArrowPoints() _x1, _y1 = self.__p1.getCoords() _x2, _y2 = self.__p2.getCoords() self.sendMessage('moved', _x1, _y1, _x2, _y2, _pt.x, _pt.y) self.modified() p3 = property(getP3, setP3, None, "Third endpoint of the Leader.") def getArrowSize(self): """Return the size of the leader line arrow. getArrowSize() """ return self.__size def setArrowSize(self, size): """Set the size of the leader line arrow. setSize(size) Argument 'size' should be a float greater than or equal to 0.0. """ if self.isLocked(): raise RuntimeError, "Cannot change arrow size - object locked." _size = util.get_float(size) if _size < 0.0: raise ValueError, "Invalid arrow size: %g" % _size _os = self.__size if abs(_os - _size) > 1e-10: self.startChange('size_changed') self.__size = _size self.endChange('size_changed') self.calcArrowPoints() self.sendMessage('size_changed', _os) self.modified() arrowsize = property(getArrowSize, setArrowSize, None, "Leader line arrow size.") def calcArrowPoints(self): """Calculate where the Leader arrow points are. calcArrowPoints() """ _x1, _y1 = self.__p2.getCoords() _x2, _y2 = self.__p3.getCoords() if abs(_x2 - _x1) < 1e-10: # vertical _cosine = 0.0 if _y2 > _y1: _sine = 1.0 else: _sine = -1.0 elif abs(_y2 - _y1) < 1e-10: # horizontal _sine = 0.0 if _x2 > _x1: _cosine = 1.0 else: _cosine = -1.0 else: _angle = math.atan2((_y2 - _y1), (_x2 - _x1)) _sine = math.sin(_angle) _cosine = math.cos(_angle) _size = self.__size _height = _size/5.0 # p1 -> (x,y) = (-size, _height) self.__arrow_pts[0] = (_cosine * (-_size) - _sine * _height) + _x2 self.__arrow_pts[1] = (_sine * (-_size) + _cosine * _height) + _y2 # p2 -> (x,y) = (-size, -_height) self.__arrow_pts[2] = (_cosine * (-_size) - _sine *(-_height)) + _x2 self.__arrow_pts[3] = (_sine * (-_size) + _cosine *(-_height)) + _y2 def getArrowPoints(self): """Return the endpoints of the Leader arrow. getArrowPoints() This method returns an array holding four float values. """ return self.__arrow_pts def move(self, dx, dy): """Move a Leader. move(dx, dy) The first argument gives the x-coordinate displacement, and the second gives the y-coordinate displacement. Both values should be floats. """ if (self.isLocked() or self.__p1.isLocked() or self.__p2.isLocked() or self.__p3.isLocked()): raise RuntimeError, "Moving Leader not allowed - object locked." _dx = util.get_float(dx) _dy = util.get_float(dy) if abs(_dx) > 1e-10 or abs(_dy) > 1e-10: _x1, _y1 = self.__p1.getCoords() _x2, _y2 = self.__p2.getCoords() _x3, _y3 = self.__p3.getCoords() self.ignore('moved') try: self.__p1.move(_dx, _dy) self.__p2.move(_dx, _dy) self.__p3.move(_dx, _dy) finally: self.receive('moved') self.calcArrowPoints() self.sendMessage('moved', _x1, _y1, _x2, _y2, _x3, _y3) def mapCoords(self, x, y, tol=tolerance.TOL): """Return the nearest Point on the Leader to a coordinate pair. mapCoords(x, y[, tol]) The function has two required arguments: x: A Float value giving the 'x' coordinate y: A Float value giving the 'y' coordinate There is a single optional argument: tol: A float value equal or greater than 0.0 This function is used to map a possibly near-by coordinate pair to an actual Point on the Leader. If the distance between the actual Point and the coordinates used as an argument is less than the tolerance, the actual Point is returned. Otherwise, this function returns None. """ _x = util.get_float(x) _y = util.get_float(y) _t = tolerance.toltest(tol) _x1, _y1 = self.__p1.getCoords() _x2, _y2 = self.__p2.getCoords() _x3, _y3 = self.__p3.getCoords() _pt = util.map_coords(_x, _y, _x1, _y1, _x2, _y2, _t) if _pt is None: _pt = util.map_coords(_x, _y, _x2, _y2, _x3, _y3, _t) if _pt is not None: return _pt return None def inRegion(self, xmin, ymin, xmax, ymax, fully=False): """Return whether or not a Leader exists within a region. isRegion(xmin, ymin, xmax, ymax[, fully]) The four arguments define the boundary of an area, and the method returns True if the Leader lies within that area. If the optional argument fully is used and is True, then all the Leader points must lie within the boundary. Otherwise, the method returns False. """ _xmin = util.get_float(xmin) _ymin = util.get_float(ymin) _xmax = util.get_float(xmax) if _xmax < _xmin: raise ValueError, "Illegal values: xmax < xmin" _ymax = util.get_float(ymax) if _ymax < _ymin: raise ValueError, "Illegal values: ymax < ymin" util.test_boolean(fully) _x1, _y1 = self.__p1.getCoords() _x2, _y2 = self.__p2.getCoords() _x3, _y3 = self.__p3.getCoords() _pxmin = min(_x1, _x2, _x3) _pymin = min(_y1, _y2, _y3) _pxmax = max(_x1, _x2, _x3) _pymax = max(_y1, _y2, _y3) if ((_pxmax < _xmin) or (_pymax < _ymin) or (_pxmin > _xmax) or (_pymin > _ymax)): return False if fully: if ((_pxmin > _xmin) and (_pymin > _ymin) and (_pxmax < _xmax) and (_pymax < _ymax)): return True return False if util.in_region(_x1, _y1, _x2, _y2, _xmin, _ymin, _xmax, _ymax): return True return util.in_region(_x2, _y2, _x3, _y3, _xmin, _ymin, _xmax, _ymax) def __pointChangePending(self, p, *args): _alen = len(args) if _alen < 1: raise ValueError, "Invalid argument count: %d" % _alen if args[0] == 'moved': self.startChange('moved') def __pointChangeComplete(self, p, *args): _alen = len(args) if _alen < 1: raise ValueError, "Invalid argument count: %d" % _alen if args[0] == 'moved': if p is self.__p2 or p is self.__p3: self.calcArrowPoints() self.endChange('moved') def __movePoint(self, p, *args): _alen = len(args) if _alen < 2: raise ValueError, "Invalid argument count: %d" % _alen _x = util.get_float(args[0]) _y = util.get_float(args[1]) _p1 = self.__p1 _p2 = self.__p2 _p3 = self.__p3 if p is _p1: _x1 = _x _y1 = _y _x2, _y2 = _p2.getCoords() _x3, _y3 = _p3.getCoords() elif p is _p2: _x1, _y1 = _p1.getCoords() _x2 = _x _y2 = _y _x3, _y3 = _p3.getCoords() elif p is _p3: _x1, _y1 = _p1.getCoords() _x2, _y2 = _p2.getCoords() _x3 = _x _y3 = _y else: raise ValueError, "Unexpected Leader endpoint: " + `p` self.sendMessage('moved', _x1, _y1, _x2, _y2, _x3, _y3) def clone(self): """Create an identical copy of a Leader. clone() """ _cp1 = self.__p1.clone() _cp2 = self.__p2.clone() _cp3 = self.__p3.clone() _size = self.__size _st = self.getStyle() _lt = self.getLinetype() _col = self.getColor() _th = self.getThickness() return Leader(_cp1, _cp2, _cp3, _size, _st, _lt, _col, _th) def sendsMessage(self, m): if m in Leader.__messages: return True return super(Leader, self).sendsMessage(m) # # Quadtree Leader storage # class LeaderQuadtree(quadtree.Quadtree): def __init__(self): super(LeaderQuadtree, self).__init__() def getNodes(self, *args): _alen = len(args) if _alen != 4: raise ValueError, "Expected 4 arguments, got %d" % _alen _lxmin = util.get_float(args[0]) _lymin = util.get_float(args[1]) _lxmax = util.get_float(args[2]) if not _lxmax > _lxmin: raise ValueError, "xmax not greater than xmin" _lymax = util.get_float(args[3]) if not _lymax > _lymin: raise ValueError, "ymax not greater than ymin" _nodes = [self.getTreeRoot()] while len(_nodes): _node = _nodes.pop() _xmin, _ymin, _xmax, _ymax = _node.getBoundary() if ((_lxmin > _xmax) or (_lxmax < _xmin) or (_lymin > _ymax) or (_lymax < _ymin)): continue if _node.hasSubnodes(): _xmid = (_xmin + _xmax)/2.0 _ymid = (_ymin + _ymax)/2.0 _ne = _nw = _sw = _se = True if _lxmax < _xmid: # leader on left side _ne = _se = False if _lxmin > _xmid: # leader on right side _nw = _sw = False if _lymax < _ymid: # leader below _nw = _ne = False if _lymin > _ymid: # leader above _sw = _se = False if _ne: _nodes.append(_node.getSubnode(quadtree.QTreeNode.NENODE)) if _nw: _nodes.append(_node.getSubnode(quadtree.QTreeNode.NWNODE)) if _sw: _nodes.append(_node.getSubnode(quadtree.QTreeNode.SWNODE)) if _se: _nodes.append(_node.getSubnode(quadtree.QTreeNode.SENODE)) else: yield _node def addObject(self, obj): if not isinstance(obj, Leader): raise TypeError, "Invalid Leader object: " + `obj` if obj in self: return _p1, _p2, _p3 = obj.getPoints() _x1, _y1 = _p1.getCoords() _x2, _y2 = _p2.getCoords() _x3, _y3 = _p3.getCoords() _bounds = self.getTreeRoot().getBoundary() _xmin = _ymin = _xmax = _ymax = None _lxmin = min(_x1, _x2, _x3) _lxmax = max(_x1, _x2, _x3) _lymin = min(_y1, _y2, _y3) _lymax = max(_y1, _y2, _y3) _resize = False if _bounds is None: # first node in tree _resize = True _xmin = _lxmin - 1.0 _ymin = _lymin - 1.0 _xmax = _lxmax + 1.0 _ymax = _lymax + 1.0 else: _xmin, _ymin, _xmax, _ymax = _bounds if _lxmin < _xmin: _xmin = _lxmin - 1.0 _resize = True if _lxmax > _xmax: _xmax = _lxmax + 1.0 _resize = True if _lymin < _ymin: _ymin = _lymin - 1.0 _resize = True if _lymax > _ymax: _ymax = _lymax + 1.0 _resize = True if _resize: self.resize(_xmin, _ymin, _xmax, _ymax) for _node in self.getNodes(_lxmin, _lymin, _lxmax, _lymax): _xmin, _ymin, _xmax, _ymax = _node.getBoundary() if obj.inRegion(_xmin, _ymin, _xmax, _ymax): _node.addObject(obj) super(LeaderQuadtree, self).addObject(obj) obj.connect('moved', self._moveLeader) def delObject(self, obj): if obj not in self: return _p1, _p2, _p3 = obj.getPoints() _x1, _y1 = _p1.getCoords() _x2, _y2 = _p2.getCoords() _x3, _y3 = _p3.getCoords() _lxmin = min(_x1, _x2, _x3) _lxmax = max(_x1, _x2, _x3) _lymin = min(_y1, _y2, _y3) _lymax = max(_y1, _y2, _y3) _pdict = {} for _node in self.getNodes(_lxmin, _lymin, _lxmax, _lymax): _node.delObject(obj) # leader may not be in the node ... _parent = _node.getParent() if _parent is not None: _pid = id(_parent) if _pid not in _pdict: _pdict[_pid] = _parent super(LeaderQuadtree, self).delObject(obj) obj.disconnect(self) for _parent in _pdict.values(): self.purgeSubnodes(_parent) def find(self, *args): _alen = len(args) if _alen < 6: raise ValueError, "Invalid argument count: %d" % _alen _x1 = util.get_float(args[0]) _y1 = util.get_float(args[1]) _x2 = util.get_float(args[2]) _y2 = util.get_float(args[3]) _x3 = util.get_float(args[4]) _y3 = util.get_float(args[5]) _t = tolerance.TOL if _alen > 6: _t = tolerance.toltest(args[6]) _xmin = min(_x1, _x2, _x3) - _t _xmax = max(_x1, _x2, _x3) + _t _ymin = min(_y1, _y2, _y3) - _t _ymax = max(_y1, _y2, _y3) + _t _leaders = [] for _leader in self.getInRegion(_xmin, _ymin, _xmax, _ymax): _p1, _p2, _p3 = _leader.getPoints() if ((abs(_p1.x - _x1) < _t) and (abs(_p1.y - _y1) < _t) and (abs(_p2.x - _x2) < _t) and (abs(_p2.y - _y2) < _t) and (abs(_p3.x - _x3) < _t) and (abs(_p3.y - _y3) < _t)): _leaders.append(_leader) return _leaders def _moveLeader(self, obj, *args): if obj not in self: raise ValueError, "Leader not stored in Quadtree: " + `obj` _alen = len(args) if _alen < 6: raise ValueError, "Invalid argument count: %d" % _alen _x1 = util.get_float(args[0]) _y1 = util.get_float(args[1]) _x2 = util.get_float(args[2]) _y2 = util.get_float(args[3]) _x3 = util.get_float(args[4]) _y3 = util.get_float(args[5]) _lxmin = min(_x1, _x2, _x3) _lxmax = max(_x1, _x2, _x3) _lymin = min(_y1, _y2, _y3) _lymax = max(_y1, _y2, _y3) for _node in self.getNodes(_lxmin, _lymin, _lxmax, _lymax): _node.delObject(obj) # leader may not be in node ... super(LeaderQuadtree, self).delObject(obj) obj.disconnect(self) self.addObject(obj) def getClosest(self, x, y, tol=tolerance.TOL): _x = util.get_float(x) _y = util.get_float(y) _t = tolerance.toltest(tol) _leader = _tsep = None _bailout = False _ldict = {} _nodes = [self.getTreeRoot()] while len(_nodes): _node = _nodes.pop() _xmin, _ymin, _xmax, _ymax = _node.getBoundary() if ((_x < (_xmin - _t)) or (_x > (_xmax + _t)) or (_y < (_ymin - _t)) or (_y > (_ymax + _t))): continue if _node.hasSubnodes(): _nodes.extend(_node.getSubnodes()) else: for _l in _node.getObjects(): _lid = id(_l) _p1, _p2, _p3 = _l.getPoints() if _lid not in _ldict: _px, _py = _p1.getCoords() if ((abs(_px - _x) < 1e-10) and (abs(_py - _y) < 1e-10)): _leader = _l _bailout = True break _px, _py = _p2.getCoords() if ((abs(_px - _x) < 1e-10) and (abs(_py - _y) < 1e-10)): _leader = _l _bailout = True break _px, _py = _p3.getCoords() if ((abs(_px - _x) < 1e-10) and (abs(_py - _y) < 1e-10)): _leader = _l _bailout = True break _ldict[_lid] = True _pt = _l.mapCoords(_x, _y, _t) if _pt is not None: _px, _py = _pt _sep = math.hypot((_px - _x), (_py - _y)) if _tsep is None: _tsep = _sep _leader = _l else: if _sep < _tsep: _tsep = _sep _leader = _l if _bailout: break return _leader def getInRegion(self, xmin, ymin, xmax, ymax): _xmin = util.get_float(xmin) _ymin = util.get_float(ymin) _xmax = util.get_float(xmax) if _xmax < _xmin: raise ValueError, "Illegal values: xmax < xmin" _ymax = util.get_float(ymax) if _ymax < _ymin: raise ValueError, "Illegal values: ymax < ymin" _leaders = [] if not len(self): return _leaders _nodes = [self.getTreeRoot()] _ldict = {} while len(_nodes): _node = _nodes.pop() if _node.hasSubnodes(): for _subnode in _node.getSubnodes(): _lxmin, _lymin, _lxmax, _lymax = _subnode.getBoundary() if ((_lxmin > _xmax) or (_lymin > _ymax) or (_lxmax < _xmin) or (_lymax < _ymin)): continue _nodes.append(_subnode) else: for _l in _node.getObjects(): _lid = id(_l) if _lid not in _ldict: if _l.inRegion(_xmin, _ymin, _xmax, _ymax): _leaders.append(_l) _ldict[_lid] = True return _leaders # # Leader history class # class LeaderLog(graphicobject.GraphicObjectLog): def __init__(self, l): if not isinstance(l, Leader): raise TypeError, "Invalid leader: " + `l` super(LeaderLog, self).__init__(l) l.connect('point_changed', self.__pointChanged) l.connect('size_changed', self.__sizeChanged) def __pointChanged(self, l, *args): _alen = len(args) if _alen < 2: raise ValueError, "Invalid argument count: %d" % _alen _old = args[0] if not isinstance(_old, point.Point): raise TypeError, "Invalid old endpoint: " + `_old` _new = args[1] if not isinstance(_new, point.Point): raise TypeError, "Invalid new endpoint: " + `_new` self.saveUndoData('point_changed', _old.getID(), _new.getID()) def __sizeChanged(self, l, *args): _alen = len(args) if _alen < 1: raise ValueError, "Invalid argument count: %d" % _alen _size = args[0] if not isinstance(_size, float): raise TypeError, "Unexpected type for size: " + `type(_size)` self.saveUndoData('size_changed', _size) def execute(self, undo, *args): util.test_boolean(undo) _alen = len(args) if _alen == 0: raise ValueError, "No arguments to execute()" _l = self.getObject() _op = args[0] if _op == 'point_changed': if _alen < 3: raise ValueError, "Invalid argument count: %d" % _alen _oid = args[1] _nid = args[2] _p1, _p2, _p3 = _l.getPoints() _parent = _l.getParent() if _parent is None: raise ValueError, "Leader has no parent - cannot undo" self.ignore(_op) try: if undo: _pt = _parent.getObject(_oid) if _pt is None or not isinstance(_pt, point.Point): raise ValueError, "Old point missing: id=%d" % _oid _l.startUndo() try: if _p1.getID() == _nid: _l.setP1(_pt) elif _p2.getID() == _nid: _l.setP2(_pt) elif _p3.getID() == _nid: _l.setP3(_pt) else: raise ValueError, "Unexpected point ID: %d" % _nid finally: _l.endUndo() else: _pt = _parent.getObject(_nid) if _pt is None or not isinstance(_pt, point.Point): raise ValueError, "New point missing: id=%d" % _nid _l.startRedo() try: if _p1.getID() == _oid: _l.setP1(_pt) elif _p2.getID() == _oid: _l.setP2(_pt) elif _p3.getID() == _oid: _l.setP3(_pt) else: raise ValueError, "Unexpected point ID: %d" % _oid finally: _l.endRedo() finally: self.receive(_op) self.saveData(undo, _op, _oid, _nid) elif _op == 'size_changed': if len(args) < 2: raise ValueError, "Invalid argument count: %d" % _alen _size = args[1] if not isinstance(_size, float): raise TypeError, "Unexpected type for size: " + `type(_size)` _sdata = _l.getArrowSize() self.ignore(_op) try: if undo: _l.startUndo() try: _l.setArrowSize(_size) finally: _l.endUndo() else: _l.startRedo() try: _l.setArrowSize(_size) finally: _l.endRedo() finally: self.receive(_op) self.saveData(undo, _op, _sdata) else: super(LeaderLog, self).execute(undo, *args)