def execute(self, undo, *args):
util.test_boolean(undo)
_alen = len(args)
if _alen == 0:
raise ValueError, "No arguments to execute()"
_f = self.getObject()
_op = args[0]
if _op == 'radius_changed':
if len(args) < 2:
raise ValueError, "Invalid argument count: %d" % _alen
_r = args[1]
if not isinstance(_r, float):
raise TypeError, "Unexpected type for radius: " + `type(_r)`
_sdata = _f.getRadius()
self.ignore(_op)
try:
if undo:
_f.startUndo()
try:
_f.setRadius(_r)
finally:
_f.endUndo()
else:
_f.startRedo()
try:
_f.setRadius(_r)
finally:
_f.endRedo()
finally:
self.receive(_op)
self.saveData(undo, _op, _sdata)
else:
super(FilletLog, self).execute(undo, *args)
def execute(self, undo, *args):
util.test_boolean(undo)
_alen = len(args)
if _alen == 0:
raise ValueError, "No arguments to execute()"
_c = self.getObject()
_op = args[0]
if _op == 'length_changed':
if len(args) < 2:
raise ValueError, "Invalid argument count: %d" % _alen
_l = args[1]
if not isinstance(_l, float):
raise TypeError, "Unexpected type for length: " + `type(_l)`
_sdata = _c.getLength()
self.ignore(_op)
try:
if undo:
_c.startUndo()
try:
_c.setLength(_l)
finally:
_c.endUndo()
else:
_c.startRedo()
try:
_c.setLength(_l)
finally:
_c.endRedo()
finally:
self.receive(_op)
self.saveData(undo, _op, _sdata)
else:
super(ChamferLog, self).execute(undo, *args)
def __visibilityChanged(self, obj, *args):
_alen = len(args)
if _alen < 1:
raise ValueError, "Invalid argument count: %d" % _alen
_vis = args[0]
util.test_boolean(_vis)
self.saveUndoData('visibilty_changed', _vis)
def __lockChanged(self, obj, *args):
_alen = len(args)
if _alen < 1:
raise ValueError, "Invalid argument count: %d" % _alen
_lock = args[0]
util.test_boolean(_lock)
self.saveUndoData('lock_changed', _lock)
def __init__(self, objs, external=True):
"""Initialize a Path.
p = Path(objs[, external])
The required argument 'objs' is a list of objects defining
the path. The valid objects are circles, arcs, segments,
chamfers and fillets.
The optional argument 'external' is by default True, meaning
that this Path is an outer boundary. If the argument is False,
then the Path represents an internal non-hatched area inside
another Path.
"""
if not isinstance(objs, list):
raise TypeError, "Unexpected list type: " + ` type(objs) `
if not len(objs):
raise ValueError, "Invalid empty object list"
for _obj in objs:
_valid = False
if (isinstance(_obj, segment.Segment) or isinstance(_obj, arc.Arc)
or isinstance(_obj, circle.Circle)
or isinstance(_obj, segjoint.Chamfer)
or isinstance(_obj, segjoint.Fillet)):
_valid = True
if not _valid:
raise TypeError, "Invalid object type in list: " + ` type(
_obj) `
_circular = False
if len(objs) == 1:
_circular = True
_obj = objs[0]
_valid = False
if isinstance(_obj, arc.Arc):
_sa = _obj.getStartAngle()
_ea = _obj.getEndAngle()
if abs(_sa - _ea) < 1e-10:
_valid = True
if not _valid:
raise ValueError, "Invalid single Arc path: " + str(_obj)
elif isinstance(_obj, circle.Circle):
pass
else:
raise TypeError, "Invalid single entity path: " + str(_obj)
else:
_valid = True
for _obj in objs:
if isinstance(_obj, circle.Circle):
if not isinstance(_obj, arc.Arc):
_valid = False
break
if not _valid:
raise TypeError, "Circle found in multi-object path"
_valid = True # _validate_path(objlist)
if not _valid:
raise ValueError, "Objlist objects do not make a closed path."
util.test_boolean(external)
self.__objs = objs[:]
self.__circular = _circular
self.__external = external
def execute(self, undo, *args):
# print "EntityLog::execute() ..."
# print args
util.test_boolean(undo)
_alen = len(args)
if len(args) == 0:
raise ValueError, "No arguments to execute()"
_obj = self.__obj
_op = args[0]
if _op == 'visibility_changed':
if len(args) < 2:
raise ValueError, "Invalid argument count: %d" % _alen
_sdata = _obj.getVisibility()
self.ignore(_op)
try:
_vis = args[1]
if undo:
_obj.startUndo()
try:
_obj.setVisibility(_vis)
finally:
_obj.endUndo()
else:
_obj.startRedo()
try:
_obj.setVisibility(_vis)
finally:
_obj.endRedo()
finally:
self.receive(_op)
self.saveData(undo, _op, _sdata)
elif _op == 'lock_changed':
if len(args) < 2:
raise ValueError, "Invalid argument count: %d" % _alen
_sdata = _obj.isLocked()
self.ignore(_op)
try:
_lock = args[1]
if undo:
_obj.startUndo()
try:
_obj.setLock(_lock)
finally:
_obj.endUndo()
else:
_obj.startRedo()
try:
_obj.setLock(_lock)
finally:
_obj.endRedo()
finally:
self.receive(_op)
self.saveData(undo, _op, _sdata)
else:
raise ValueError, "Unexpected operation: %s" % _op
def setLock(self, lock):
"""Set the locked status on an entity.
setLock(lock)
Argument 'lock' can be True or False.
"""
util.test_boolean(lock)
_l = self.__locked
if _l is not lock:
self.__locked = lock
self.sendMessage('lock_changed', _l)
self.modified()
def execute(self, undo, *args):
util.test_boolean(undo)
_alen = len(args)
if len(args) == 0:
raise ValueError, "No arguments to execute()"
_c = self.getObject()
_p1, _p2 = _c.getKeypoints()
_op = args[0]
if _op == 'keypoint_changed':
if _alen < 3:
raise ValueError, "Invalid argument count: %d" % _alen
_oid = args[1]
_nid = args[2]
_parent = _c.getParent()
if _parent is None:
raise ValueError, "CLine 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 keypoint missing: id=%d" % _oid
_c.startUndo()
try:
if _p1.getID() == _nid:
_c.setP1(_pt)
elif _p2.getID() == _nid:
_c.setP2(_pt)
else:
raise ValueError, "Unexpected keypoint ID: %d" % _nid
finally:
_c.endUndo()
else:
_pt = _parent.getObject(_nid)
if _pt is None or not isinstance(_pt, point.Point):
raise ValueError, "New keypoint missing: id=%d" % _nid
_c.startRedo()
try:
if _p1.getID() == _oid:
_c.setP1(_pt)
elif _p2.getID() == _oid:
_c.setP2(_pt)
else:
raise ValueError, "Unexpected keypoint ID: %d" % _oid
finally:
_c.endRedo()
finally:
self.receive(_op)
self.saveData(undo, _op, _oid, _nid)
else:
super(CLineLog, self).execute(undo, *args)
def setVisibility(self, vis):
"""Set the visibility of the entity.
setVisibility(vis)
Argument 'vis' must be either True or False.
"""
util.test_boolean(vis)
_v = self.__visible
if _v is not vis:
self.startChange('visibility_changed')
self.__visible = vis
self.endChange('visibility_changed')
self.sendMessage('visibility_changed', _v)
self.modified()
def inRegion(self, xmin, ymin, xmax, ymax, fully=False):
"""Return whether or not a CLine passes through a region.
isRegion(xmin, ymin, xmax, ymax)
The four arguments define the boundary of an area, and the
function returns True if the CLine passes within the area.
Otherwise, the function 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)
if fully:
return False
_x1, _y1 = self.__p1.getCoords()
_x2, _y2 = self.__p2.getCoords()
_xdiff = _x2 - _x1
_ydiff = _y2 - _y1
_val = False
if _xmin < _x1 < _xmax and _ymin < _y1 < _ymax:
_val = True
elif _xmin < _x2 < _xmax and _ymin < _y2 < _ymax:
_val = True
elif abs(_xdiff) < 1e-10: # vertical line
if _xmin < _x1 < _xmax:
_val = True
elif abs(_ydiff) < 1e-10: # horizontal line
if _ymin < _y1 < _ymax:
_val = True
else:
_slope = _ydiff / _xdiff
_yint = _y1 - _slope * _x1
if _ymin < (_slope * _xmin + _yint) < _ymax: # hits left side
_val = True
elif _ymin < (_slope * _xmax + _yint) < _ymax: # hits right side
_val = True
else: # hits bottom - no need to check top ...
_xymin = (_ymin - _yint) / _slope
if _xmin < _xymin < _xmax:
_val = True
return _val
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 inRegion(self, xmin, ymin, xmax, ymax, fully=False):
"""Return whether or not a Polyline 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 Polyline lies within that area. If
the optional argument 'fully' is used and is True, then both
endpoints of the Polyline 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)
_pxmin, _pymin, _pxmax, _pymax = self.getBounds()
if ((_pxmax < _xmin) or
(_pxmin > _xmax) or
(_pymax < _ymin) or
(_pymin > _ymax)):
return False
if fully:
if ((_pxmin > _xmin) and
(_pymin > _ymin) and
(_pxmax < _xmax) and
(_pymax < _ymax)):
return True
return False
_pts = self.__pts
for _i in range(len(_pts) - 1):
_x1, _y1 = _pts[_i].getCoords()
_x2, _y2 = _pts[_i + 1].getCoords()
if util.in_region(_x1, _y1, _x2, _y2, _xmin, _ymin, _xmax, _ymax):
return True
return False
def inRegion(self, xmin, ymin, xmax, ymax, fully=False):
"""Return whether or not an HCLine passes through a region.
inRegion(xmin, ymin, xmax, ymax)
The first four arguments define the boundary. The method
will return True if the HCLine falls between ymin and ymax.
Otherwise the function will return 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)
if fully:
return False
_y = self.__keypoint.y
return not (_y < _ymin or _y > _ymax)
def inRegion(self, xmin, ymin, xmax, ymax, fully=False):
"""Return whether or not an VCLine passes through a region.
inRegion(xmin, ymin, xmax, ymax)
The first four arguments define the boundary. The method
will return True if the VCLine falls between xmin and xmax.
Otherwise the function will return 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)
if fully:
return False
_x = self.__keypoint.x
return not (_x < _xmin or _x > _xmax)
def inRegion(self, xmin, ymin, xmax, ymax, fully=False):
"""Return whether or not a fillet exists with a region.
isRegion(xmin, ymin, xmax, ymax)
The four arguments define the boundary of an area, and the
function returns True if the joint lies within that area.
Otherwise, the function 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)
_mp1, _mp2 = self.getMovingPoints()
_mx1, _my1 = _mp1.getCoords()
_mx2, _my2 = _mp2.getCoords()
_r = self.__radius
_xc, _yc = self.__center
_a1, _a2 = self.getAngles()
_xl = [_mx1, _mx2, _xc]
_yl = [_my1, _my2, _yc]
if fully:
if ((min(_xl) > _xmin) and
(min(_yl) > _ymin) and
(max(_xl) < _xmax) and
(max(_yl) < _ymax)):
return True
return False
#
# fixme - need to use the arc and endpoints and not
# a line connecting the endpoints ...
#
return util.in_region(_mx1, _my1, _mx2, _my2,
_xmin, _ymin, _xmax, _ymax)
def inRegion(self, xmin, ymin, xmax, ymax, fully=True):
"""Returns True if the Point is within the bounding values.
inRegion(xmin, ymin, xmax, ymax)
The four arguments define the boundary of an area, and the
function returns True if the Point lies within that area.
Otherwise, the function 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)
_x = self.__x
_y = self.__y
return not ((_x < _xmin) or (_x > _xmax) or (_y < _ymin) or
(_y > _ymax))
def inRegion(self, xmin, ymin, xmax, ymax, fully=False):
"""Return whether or not a segjoint exists with a region.
isRegion(xmin, ymin, xmax, ymax)
The four arguments define the boundary of an area, and the
function returns True if the joint lies within that area.
Otherwise, the function 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)
_mp1, _mp2 = self.getMovingPoints()
_mx1, _my1 = _mp1.getCoords()
_mx2, _my2 = _mp2.getCoords()
_fxmin = min(_mx1, _mx2)
_fymin = min(_my1, _my2)
_fxmax = max(_mx1, _mx2)
_fymax = max(_my1, _my2)
if ((_fxmax < _xmin) or
(_fymax < _ymin) or
(_fxmin > _xmax) or
(_fymin > _ymax)):
return False
if fully:
if ((_fxmin > _xmin) and
(_fymin > _ymin) and
(_fxmax < _xmax) and
(_fymax < _ymax)):
return True
return False
return util.in_region(_mx1, _my1, _mx2, _my2,
_xmin, _ymin, _xmax, _ymax)
def execute(self, undo, *args):
util.test_boolean(undo)
_alen = len(args)
if _alen == 0:
raise ValueError, "No arguments to execute()"
_h = self.getObject()
_p = _h.getLocation()
_op = args[0]
if _op == "keypoint_changed":
if _alen < 2:
raise ValueError, "Invalid argument count: %d" % _alen
_oid = args[1]
_parent = _h.getParent()
if _parent is None:
raise ValueError, "HCLine has no parent - cannot undo"
_pt = _parent.getObject(_oid)
if _pt is None or not isinstance(_pt, point.Point):
raise ValueError, "Keypoint missing: id=%d" % _oid
_sdata = _p.getID()
self.ignore(_op)
try:
if undo:
_h.startUndo()
try:
_h.setLocation(_pt)
finally:
_h.endUndo()
else:
_h.startRedo()
try:
_h.setLocation(_pt)
finally:
_h.endRedo()
finally:
self.receive(_op)
self.saveData(undo, _op, _sdata)
else:
super(HCLineLog, self).execute(undo, *args)
def execute(self, undo, *args):
util.test_boolean(undo)
_alen = len(args)
if _alen == 0:
raise ValueError, "No arguments to execute()"
_v = self.getObject()
_p = _v.getLocation()
_op = args[0]
if _op == 'keypoint_changed':
if _alen < 2:
raise ValueError, "Invalid argument count: %d" % _alen
_oid = args[1]
_parent = _v.getParent()
if _parent is None:
raise ValueError, "VCLine has no parent - cannot undo"
_pt = _parent.getObject(_oid)
if _pt is None or not isinstance(_pt, point.Point):
raise ValueError, "Keypoint missing: id=%d" % _oid
_sdata = _p.getID()
self.ignore(_op)
try:
if undo:
_v.startUndo()
try:
_v.setLocation(_pt)
finally:
_v.endUndo()
else:
_v.startRedo()
try:
_v.setLocation(_pt)
finally:
_v.endRedo()
finally:
self.receive(_op)
self.saveData(undo, _op, _sdata)
else:
super(VCLineLog, self).execute(undo, *args)
def inRegion(self, xmin, ymin, xmax, ymax, fully=True):
"""Returns True if the Point is within the bounding values.
inRegion(xmin, ymin, xmax, ymax)
The four arguments define the boundary of an area, and the
function returns True if the Point lies within that area.
Otherwise, the function 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)
_x = self.__x
_y = self.__y
return not ((_x < _xmin) or
(_x > _xmax) or
(_y < _ymin) or
(_y > _ymax))
def execute(self, undo, *args):
util.test_boolean(undo)
_alen = len(args)
if _alen == 0:
raise ValueError, "No arguments to execute()"
_p = self.getObject()
_op = args[0]
if _op == 'moved':
if _alen < 3:
raise ValueError, "Invalid argument count: %d" % _alen
_x = args[1]
if not isinstance(_x, float):
raise TypeError, "Unexpected type for 'x': " + `type(_x)`
_y = args[2]
if not isinstance(_y, float):
raise TypeError, "Unexpected type for 'y': " + `type(_y)`
_px, _py = _p.getCoords()
self.ignore(_op)
try:
if undo:
_p.startUndo()
try:
_p.setCoords(_x, _y)
finally:
_p.endUndo()
else:
_p.startRedo()
try:
_p.setCoords(_x, _y)
finally:
_p.endRedo()
finally:
self.receive(_op)
self.saveData(undo, _op, _px, _py)
else:
super(PointLog, self).execute(undo, *args)
def execute(self, undo, *args):
util.test_boolean(undo)
_alen = len(args)
if _alen == 0:
raise ValueError, "No arguments to execute()"
_p = self.getObject()
_op = args[0]
if _op == 'moved':
if _alen < 3:
raise ValueError, "Invalid argument count: %d" % _alen
_x = args[1]
if not isinstance(_x, float):
raise TypeError, "Unexpected type for 'x': " + ` type(_x) `
_y = args[2]
if not isinstance(_y, float):
raise TypeError, "Unexpected type for 'y': " + ` type(_y) `
_px, _py = _p.getCoords()
self.ignore(_op)
try:
if undo:
_p.startUndo()
try:
_p.setCoords(_x, _y)
finally:
_p.endUndo()
else:
_p.startRedo()
try:
_p.setCoords(_x, _y)
finally:
_p.endRedo()
finally:
self.receive(_op)
self.saveData(undo, _op, _px, _py)
else:
super(PointLog, self).execute(undo, *args)
def inRegion(self, xmin, ymin, xmax, ymax, fully=False):
"""Return whether or not a Polyline 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 Polyline lies within that area. If
the optional argument 'fully' is used and is True, then both
endpoints of the Polyline 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)
_pxmin, _pymin, _pxmax, _pymax = self.getBounds()
if ((_pxmax < _xmin) or (_pxmin > _xmax) or (_pymax < _ymin)
or (_pymin > _ymax)):
return False
if fully:
if ((_pxmin > _xmin) and (_pymin > _ymin) and (_pxmax < _xmax)
and (_pymax < _ymax)):
return True
return False
_pts = self.__pts
for _i in range(len(_pts) - 1):
_x1, _y1 = _pts[_i].getCoords()
_x2, _y2 = _pts[_i + 1].getCoords()
if util.in_region(_x1, _y1, _x2, _y2, _xmin, _ymin, _xmax, _ymax):
return True
return False
def saveData(self, undo, op, *args):
util.test_boolean(undo)
if undo:
self.saveRedoData(op, *args)
else:
self.saveUndoData(op, *args)
def execute(self, undo, *args):
util.test_boolean(undo)
_alen = len(args)
if len(args) == 0:
raise ValueError, "No arguments to execute()"
_obj = self.getObject()
_op = args[0]
_image = None
_layer = _obj.getParent()
if _layer is not None:
_image = _layer.getParent()
if _op == 'style_changed':
if _image is None:
raise RuntimeError, "Object not stored in an Image"
if _alen < 2:
raise ValueError, "Invalid argument count: %d" % _alen
_style = None
_sv, _olt, _oc, _ot = args[1]
_name, _ltdata, _col, _th = _sv
for _s in _image.getImageEntities('style'):
if _s.getName() != _name:
continue
_lt = _s.getLinetype()
if (_lt.getName() != _ltdata[0]
or _lt.getList() != _ltdata[1]):
continue
if _s.getColor().getColors() != _col:
continue
if abs(_s.getThickness() - _th) > 1e-10:
continue
_style = _s
break
_sdata = _obj.getGraphicValues()
if _style is not None:
self.ignore(_op)
try:
if undo:
_obj.startUndo()
try:
_obj.setStyle(_style)
finally:
_obj.endUndo()
else:
_obj.startRedo()
try:
_obj.setStyle(_style)
finally:
_obj.endRedo()
finally:
self.receive(_op)
#
# restore values differing from the Style
#
if _olt is not None:
_name, _list = _olt
_lt = None
for _l in _image.getImageEntities('linetype'):
if (_l.getName() == _name and _l.getList() == _list):
_lt = _l
break
_obj.mute()
try:
_obj.setLinetype(_lt)
finally:
_obj.unmute()
if _oc is not None:
_col = None
for _c in _image.getImageEntities('color'):
if _c.getColors() == _oc:
_col = _c
break
_obj.mute()
try:
_obj.setColor(_col)
finally:
_obj.unmute()
if _ot is not None:
_obj.mute()
try:
_obj.setThickness(_ot)
finally:
_obj.unmute()
self.saveData(undo, _op, _sdata)
elif _op == 'linetype_changed':
if _image is None:
raise RuntimeError, "Object not stored in an Image"
if _alen < 2:
raise ValueError, "Invalid argument count: %d" % _alen
_lt = _obj.getLinetype()
_sdata = (_lt.getName(), _lt.getList())
self.ignore(_op)
try:
_name, _list = args[1]
_lt = None
for _l in _image.getImageEntities('linetype'):
if (_l.getName() == _name and _l.getList() == _list):
_lt = _l
break
if undo:
_obj.startUndo()
try:
_obj.setLinetype(_lt)
finally:
_obj.endUndo()
else:
_obj.startRedo()
try:
_obj.setLinetype(_lt)
finally:
_obj.endRedo()
finally:
self.receive(_op)
self.saveData(undo, _op, _sdata)
elif _op == 'color_changed':
if _image is None:
raise RuntimeError, "Object not stored in an Image"
if _alen < 2:
raise ValueError, "Invalid argument count: %d" % _alen
_sdata = _obj.getColor().getColors()
self.ignore(_op)
try:
_col = None
for _c in _image.getImageEntities('color'):
if _c.getColors() == args[1]:
_col = _c
break
if undo:
_obj.startUndo()
try:
_obj.setColor(_col)
finally:
_obj.endUndo()
else:
_obj.startRedo()
try:
_obj.setColor(_col)
finally:
_obj.endRedo()
finally:
self.receive(_op)
self.saveData(undo, _op, _sdata)
elif _op == 'thickness_changed':
if _alen < 2:
raise ValueError, "Invalid argument count: %d" % _alen
_sdata = _obj.getThickness()
self.ignore(_op)
try:
_t = args[1]
if undo:
_obj.startUndo()
try:
_obj.setThickness(_t)
finally:
_obj.endUndo()
else:
_obj.startRedo()
try:
_obj.setThickness(_t)
finally:
_obj.endRedo()
finally:
self.receive(_op)
self.saveData(undo, _op, _sdata)
else:
super(GraphicObjectLog, self).execute(undo, *args)
def __init__(self, objs, external=True):
"""Initialize a Path.
p = Path(objs[, external])
The required argument 'objs' is a list of objects defining
the path. The valid objects are circles, arcs, segments,
chamfers and fillets.
The optional argument 'external' is by default True, meaning
that this Path is an outer boundary. If the argument is False,
then the Path represents an internal non-hatched area inside
another Path.
"""
if not isinstance(objs, list):
raise TypeError, "Unexpected list type: " + ` type(objs) `
if not len(objs):
raise ValueError, "Invalid empty object list"
for _obj in objs:
_valid = False
if (
isinstance(_obj, segment.Segment)
or isinstance(_obj, arc.Arc)
or isinstance(_obj, circle.Circle)
or isinstance(_obj, segjoint.Chamfer)
or isinstance(_obj, segjoint.Fillet)
):
_valid = True
if not _valid:
raise TypeError, "Invalid object type in list: " + ` type(_obj) `
_circular = False
if len(objs) == 1:
_circular = True
_obj = objs[0]
_valid = False
if isinstance(_obj, arc.Arc):
_sa = _obj.getStartAngle()
_ea = _obj.getEndAngle()
if abs(_sa - _ea) < 1e-10:
_valid = True
if not _valid:
raise ValueError, "Invalid single Arc path: " + str(_obj)
elif isinstance(_obj, circle.Circle):
pass
else:
raise TypeError, "Invalid single entity path: " + str(_obj)
else:
_valid = True
for _obj in objs:
if isinstance(_obj, circle.Circle):
if not isinstance(_obj, arc.Arc):
_valid = False
break
if not _valid:
raise TypeError, "Circle found in multi-object path"
_valid = True # _validate_path(objlist)
if not _valid:
raise ValueError, "Objlist objects do not make a closed path."
util.test_boolean(external)
self.__objs = objs[:]
self.__circular = _circular
self.__external = external
def execute(self, undo, *args):
#
# fixme - deal with the endpoints ...
#
def _used_by(obj, plist):
_objpt = None
for _pt in plist:
for _user in _pt.getUsers():
if _user is obj:
_objpt = _pt
break
if _objpt is not None:
break
return _objpt
def _most_used(plist):
_pmax = plist.pop()
_max = _pmax.countUsers()
for _pt in plist:
_count = _pt.countUsers()
if _count > _max:
_max = _count
_pmax = _pt
return _pmax
util.test_boolean(undo)
_alen = len(args)
if _alen == 0:
raise ValueError, "No arguments to execute()"
_a = self.getObject()
_cp = _a.getCenter()
_op = args[0]
if _op == 'center_changed':
if _alen < 2:
raise ValueError, "Invalid argument count: %d" % _alen
_oid = args[1]
_parent = _a.getParent()
if _parent is None:
raise ValueError, "Arc has no parent - cannot undo"
_pt = _parent.getObject(_oid)
if _pt is None or not isinstance(_pt, point.Point):
raise ValueError, "Center point missing: id=%d" % _oid
_ep1, _ep2 = _a.getEndpoints()
_pts = _parent.find('point', _ep1[0], _ep1[1])
_ep = _used_by(_a, _pts)
assert _ep is not None, "Arc endpoint not found in layer"
_ep.freeUser(_a)
_pts = _parent.find('point', _ep2[0], _ep2[1])
_ep = _used_by(_a, _pts)
assert _ep is not None, "Arc endpoint not found in layer"
_ep.freeUser(_a)
_sdata = _cp.getID()
self.ignore(_op)
try:
if undo:
_a.startUndo()
try:
_a.setCenter(_pt)
finally:
_a.endUndo()
else:
_a.startRedo()
try:
_a.setCenter(_pt)
finally:
_a.endRedo()
finally:
self.receive(_op)
_ep1, _ep2 = _a.getEndpoints()
_pts = _parent.find('point', _ep1[0], _ep1[1])
_ep = _most_used(_pts)
_ep.storeUser(_a)
_pts = _parent.find('point', _ep2[0], _ep2[1])
_ep = _most_used(_pts)
_ep.storeUser(_a)
self.saveData(undo, _op, _sdata)
elif _op == 'radius_changed':
if len(args) < 2:
raise ValueError, "Invalid argument count: %d" % _alen
_r = args[1]
if not isinstance(_r, float):
raise TypeError, "Unexpected type for radius: " + ` type(_r) `
_sdata = _a.getRadius()
self.ignore(_op)
try:
if undo:
_a.startUndo()
try:
_a.setRadius(_r)
finally:
_a.endUndo()
else:
_a.startRedo()
try:
_a.setRadius(_r)
finally:
_a.endRedo()
finally:
self.receive(_op)
self.saveData(undo, _op, _sdata)
elif _op == 'start_angle_changed':
if len(args) < 2:
raise ValueError, "Invalid argument count: %d" % _alen
_sa = args[1]
if not isinstance(_sa, float):
raise TypeError, "Unexpected type for angle: " + ` type(_sa) `
_sdata = _a.getStartAngle()
self.ignore(_op)
try:
if undo:
_a.startUndo()
try:
_a.setStartAngle(_sa)
finally:
_a.endUndo()
else:
_a.startRedo()
try:
_a.setStartAngle(_sa)
finally:
_a.endRedo()
finally:
self.receive(_op)
self.saveData(undo, _op, _sdata)
elif _op == 'end_angle_changed':
if len(args) < 2:
raise ValueError, "Invalid argument count: %d" % _alen
_ea = args[1]
if not isinstance(_ea, float):
raise TypeError, "Unexpected type for angle: " + ` type(_ea) `
_sdata = _a.getEndAngle()
self.ignore(_op)
try:
if undo:
_a.startUndo()
try:
_a.setEndAngle(_ea)
finally:
_a.endUndo()
else:
_a.startRedo()
try:
_a.setEndAngle(_ea)
finally:
_a.endRedo()
finally:
self.receive(_op)
self.saveData(undo, _op, _sdata)
else:
super(ArcLog, self).execute(undo, *args)
def inRegion(self, xmin, ymin, xmax, ymax, fully=False):
"""Return whether or not an CCircle exists within a region.
inRegion(xmin, ymin, xmax, ymax[, fully])
The first four arguments define the boundary. The optional
fifth argument 'fully' indicates whether or not the CCircle
must be completely contained within the region or just pass
through it.
"""
_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)
_xc, _yc = self.__center.getCoords()
_r = self.__radius
#
# cheap test to see if ccircle cannot be in region
#
if (((_xc - _r) > _xmax) or
((_yc - _r) > _ymax) or
((_xc + _r) < _xmin) or
((_yc + _r) < _ymin)):
return False
_val = False
_bits = 0
#
# calculate distances from center to region boundary
#
if abs(_xc - _xmin) < _r: _bits = _bits | 1 # left edge
if abs(_xc - _xmax) < _r: _bits = _bits | 2 # right edge
if abs(_yc - _ymin) < _r: _bits = _bits | 4 # bottom edge
if abs(_yc - _ymax) < _r: _bits = _bits | 8 # top edge
if _bits == 0:
#
# if the ccircle center is in region then the entire
# ccircle is visible since the distance from the center
# to any edge is greater than the radius. If the center
# is not in the region then the ccircle is not visible in
# the region because the distance to any edge is greater
# than the radius, and so one of the bits should have been
# set ...
#
if ((_xmin < _xc < _xmax) and (_ymin < _yc < _ymax)):
_val = True
else:
_val = True
#
# calculate distance to corners of region
#
if math.hypot((_xc - _xmin), (_yc - _ymax)) < _r:
_bits = _bits | 0x10 # upper left
if math.hypot((_xc - _xmax), (_yc - _ymin)) < _r:
_bits = _bits | 0x20 # lower right
if math.hypot((_xc - _xmin), (_yc - _ymin)) < _r:
_bits = _bits | 0x40 # lower left
if math.hypot((_xc - _xmax), (_yc - _ymax)) < _r:
_bits = _bits | 0x80 # upper right
#
# if all bits are set then distance from ccircle center
# to region endpoints is less than radius - ccircle
# entirely outside the region
#
if _bits == 0xff or fully:
_val = False
return _val
def setLandscapeMode(self, flag):
util.test_boolean(flag)
self.__landscape = flag
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)
def inRegion(self, xmin, ymin, xmax, ymax, fully=False):
"""Return whether or not an ACLine passes through a region.
inRegion(xmin, ymin, xmax, ymax)
The first four arguments define the boundary. The method
will return True if the ACLine passes through the boundary.
Otherwise the function will return 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)
if fully:
return False
_x, _y = self.getLocation().getCoords()
_angle = self.__angle
_val = False
if _xmin < _x < _xmax and _ymin < _y < _ymax:
_val = True
elif self.isHorizontal() and _ymin < _y < _ymax:
_val = True
elif self.isVertical() and _xmin < _x < _xmax:
_val = True
else:
#
# the ACLine can be parameterized as
#
# x = u * (x2 - x1) + x1
# y = u * (y2 - y1) + y1
#
# for u = 0, x => x1, y => y1
# for u = 1, x => x2, y => y2
#
# if the ACLine passes through the region then there
# will be valid u occuring at the region boundary
#
_rangle = _angle * _dtr
_dx = math.cos(_rangle)
_dy = math.sin(_rangle)
#
# x = xmin
#
_u = (_xmin - _x)/_dx
_yt = (_u * _dy) + _y
if (_ymin - 1e-10) < _yt < (_ymax + 1e-10): # catch endpoints
_val = True
if not _val:
#
# x = xmax
#
_u = (_xmax - _x)/_dx
_yt = (_u * _dy) + _y
if (_ymin - 1e-10) < _yt < (_ymax + 1e-10): # catch endpoints
_val = True
if not _val:
#
# y = ymin
#
# if this fails there is no way the ACLine can be in
# region because it cannot pass through only one side
#
_u = (_ymin - _y)/_dy
_xt = (_u * _dx) + _x
if _xmin < _xt < _xmax:
_val = True
return _val
def execute(self, undo, *args):
#
# fixme - deal with the endpoints ...
#
def _used_by(obj, plist):
_objpt = None
for _pt in plist:
for _user in _pt.getUsers():
if _user is obj:
_objpt = _pt
break
if _objpt is not None:
break
return _objpt
def _most_used(plist):
_pmax = plist.pop()
_max = _pmax.countUsers()
for _pt in plist:
_count = _pt.countUsers()
if _count > _max:
_max = _count
_pmax = _pt
return _pmax
util.test_boolean(undo)
_alen = len(args)
if _alen == 0:
raise ValueError, "No arguments to execute()"
_a = self.getObject()
_cp = _a.getCenter()
_op = args[0]
if _op == 'center_changed':
if _alen < 2:
raise ValueError, "Invalid argument count: %d" % _alen
_oid = args[1]
_parent = _a.getParent()
if _parent is None:
raise ValueError, "Arc has no parent - cannot undo"
_pt = _parent.getObject(_oid)
if _pt is None or not isinstance(_pt, point.Point):
raise ValueError, "Center point missing: id=%d" % _oid
_ep1, _ep2 = _a.getEndpoints()
_pts = _parent.find('point', _ep1[0], _ep1[1])
_ep = _used_by(_a, _pts)
assert _ep is not None, "Arc endpoint not found in layer"
_ep.freeUser(_a)
_pts = _parent.find('point', _ep2[0], _ep2[1])
_ep = _used_by(_a, _pts)
assert _ep is not None, "Arc endpoint not found in layer"
_ep.freeUser(_a)
_sdata = _cp.getID()
self.ignore(_op)
try:
if undo:
_a.startUndo()
try:
_a.setCenter(_pt)
finally:
_a.endUndo()
else:
_a.startRedo()
try:
_a.setCenter(_pt)
finally:
_a.endRedo()
finally:
self.receive(_op)
_ep1, _ep2 = _a.getEndpoints()
_pts = _parent.find('point', _ep1[0], _ep1[1])
_ep = _most_used(_pts)
_ep.storeUser(_a)
_pts = _parent.find('point', _ep2[0], _ep2[1])
_ep = _most_used(_pts)
_ep.storeUser(_a)
self.saveData(undo, _op, _sdata)
elif _op == 'radius_changed':
if len(args) < 2:
raise ValueError, "Invalid argument count: %d" % _alen
_r = args[1]
if not isinstance(_r, float):
raise TypeError, "Unexpected type for radius: " + `type(_r)`
_sdata = _a.getRadius()
self.ignore(_op)
try:
if undo:
_a.startUndo()
try:
_a.setRadius(_r)
finally:
_a.endUndo()
else:
_a.startRedo()
try:
_a.setRadius(_r)
finally:
_a.endRedo()
finally:
self.receive(_op)
self.saveData(undo, _op, _sdata)
elif _op == 'start_angle_changed':
if len(args) < 2:
raise ValueError, "Invalid argument count: %d" % _alen
_sa = args[1]
if not isinstance(_sa, float):
raise TypeError, "Unexpected type for angle: " + `type(_sa)`
_sdata = _a.getStartAngle()
self.ignore(_op)
try:
if undo:
_a.startUndo()
try:
_a.setStartAngle(_sa)
finally:
_a.endUndo()
else:
_a.startRedo()
try:
_a.setStartAngle(_sa)
finally:
_a.endRedo()
finally:
self.receive(_op)
self.saveData(undo, _op, _sdata)
elif _op == 'end_angle_changed':
if len(args) < 2:
raise ValueError, "Invalid argument count: %d" % _alen
_ea = args[1]
if not isinstance(_ea, float):
raise TypeError, "Unexpected type for angle: " + `type(_ea)`
_sdata = _a.getEndAngle()
self.ignore(_op)
try:
if undo:
_a.startUndo()
try:
_a.setEndAngle(_ea)
finally:
_a.endUndo()
else:
_a.startRedo()
try:
_a.setEndAngle(_ea)
finally:
_a.endRedo()
finally:
self.receive(_op)
self.saveData(undo, _op, _sdata)
else:
super(ArcLog, self).execute(undo, *args)
def execute(self, undo, *args):
util.test_boolean(undo)
_alen = len(args)
if _alen == 0:
raise ValueError, "No arguments to execute()"
_c = self.getObject()
_cp = _c.getCenter()
_op = args[0]
if _op == 'radius_changed':
if len(args) < 2:
raise ValueError, "Invalid argument count: %d" % _alen
_r = args[1]
if not isinstance(_r, float):
raise TypeError, "Unexpected type for radius: " + `type(_r)`
_sdata = _c.getRadius()
self.ignore(_op)
try:
if undo:
_c.startUndo()
try:
_c.setRadius(_r)
finally:
_c.endUndo()
else:
_c.startRedo()
try:
_c.setRadius(_r)
finally:
_c.endRedo()
finally:
self.receive(_op)
self.saveData(undo, _op, _sdata)
elif _op == 'center_changed':
if _alen < 2:
raise ValueError, "Invalid argument count: %d" % _alen
_oid = args[1]
_parent = _c.getParent()
if _parent is None:
raise ValueError, "CCircle has no parent - cannot undo"
_pt = _parent.getObject(_oid)
if _pt is None or not isinstance(_pt, point.Point):
raise ValueError, "Center point missing: id=%d" % _oid
_sdata = _cp.getID()
self.ignore(_op)
try:
if undo:
_c.startUndo()
try:
_c.setCenter(_pt)
finally:
_c.endUndo()
else:
_c.startRedo()
try:
_c.setCenter(_pt)
finally:
_c.endRedo()
finally:
self.receive(_op)
self.saveData(undo, _op, _sdata)
else:
super(CCircleLog, self).execute(undo, *args)
def inRegion(self, xmin, ymin, xmax, ymax, fully=False):
"""Return whether or not an Arc exists within a region.
inRegion(xmin, ymin, xmax, ymax[, fully])
The first four arguments define the boundary. The optional
fifth argument fully indicates whether or not the Arc
must be completely contained within the region or just pass
through it.
"""
_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)
_xc, _yc = self.__center.getCoords()
_r = self.__radius
#
# cheap test to see if arc cannot be in region
#
_axmin, _aymin, _axmax, _aymax = self.getBounds()
if ((_axmin > _xmax) or (_aymin > _ymax) or (_axmax < _xmin)
or (_aymax < _ymin)):
return False
_val = False
_bits = 0
#
# calculate distances from center to region boundary
#
if abs(_xc - _xmin) < _r: _bits = _bits | 1 # left edge
if abs(_xc - _xmax) < _r: _bits = _bits | 2 # right edge
if abs(_yc - _ymin) < _r: _bits = _bits | 4 # bottom edge
if abs(_yc - _ymax) < _r: _bits = _bits | 8 # top edge
if _bits == 0:
#
# arc must be visible - the center is in
# the region and is more than the radius from
# each edge
#
_val = True
else:
#
# calculate distance to corners of region
#
if math.hypot((_xc - _xmin), (_yc - _ymax)) < _r:
_bits = _bits | 0x10 # upper left
if math.hypot((_xc - _xmax), (_yc - _ymin)) < _r:
_bits = _bits | 0x20 # lower right
if math.hypot((_xc - _xmin), (_yc - _ymin)) < _r:
_bits = _bits | 0x40 # lower left
if math.hypot((_xc - _xmax), (_yc - _ymax)) < _r:
_bits = _bits | 0x80 # upper right
#
# if all bits are set then distance from arc center
# to region endpoints is less than radius - arc
# entirely outside the region
#
_val = not ((_bits == 0xff) or fully)
#
# if the test value is still true, check that the
# arc boundary can overlap with the region
#
if _val:
_ep1, _ep2 = self.getEndpoints()
_axmin = min(_xc, _ep1[0], _ep2[0])
if self.throughAngle(180.0):
_axmin = _xc - _r
if _axmin > _xmax:
return False
_aymin = min(_yc, _ep1[1], _ep2[1])
if self.throughAngle(270.0):
_aymin = _yc - _r
if _aymin > _ymax:
return False
_axmax = max(_xc, _ep1[0], _ep2[0])
if self.throughAngle(0.0):
_axmax = _xc + _r
if _axmax < _xmin:
return False
_aymax = max(_yc, _ep1[1], _ep2[1])
if self.throughAngle(90.0):
_aymax = _yc + _r
if _aymax < _ymin:
return False
return _val
def setColorMode(self, flag):
util.test_boolean(flag)
self.__color = flag
def invertWhite(self, flag):
util.test_boolean(flag)
self.__invert = flag
def execute(self, undo, *args):
util.test_boolean(undo)
_alen = len(args)
if _alen == 0:
raise ValueError, "No arguments to execute()"
_a = self.getObject()
_p = _a.getLocation()
_op = args[0]
if _op == 'rotated':
if len(args) < 2:
raise ValueError, "Invalid argument count: %d" % _alen
_angle = args[1]
if not isinstance(_angle, float):
raise TypeError, "Unexpected type for angle: " + `type(_angle)`
_sdata = _a.getAngle()
self.ignore(_op)
try:
if undo:
_a.startUndo()
try:
_a.setAngle(_angle)
finally:
_a.endUndo()
else:
_a.startRedo()
try:
_a.setAngle(_angle)
finally:
_a.endRedo()
finally:
self.receive(_op)
self.saveData(undo, _op, _sdata)
elif _op == 'keypoint_changed':
if _alen < 2:
raise ValueError, "Invalid argument count: %d" % _alen
_oid = args[1]
_parent = _a.getParent()
if _parent is None:
raise ValueError, "ACLine has no parent - cannot undo"
_pt = _parent.getObject(_oid)
if _pt is None or not isinstance(_pt, point.Point):
raise ValueError, "Keypoint missing: id=%d" % _oid
_sdata = _p.getID()
self.ignore(_op)
try:
if undo:
_a.startUndo()
try:
_a.setLocation(_pt)
finally:
_a.endUndo()
else:
_a.startRedo()
try:
_a.setLocation(_pt)
finally:
_a.endRedo()
finally:
self.receive(_op)
self.saveData(undo, _op, _sdata)
else:
super(ACLineLog, self).execute(undo, *args)
def execute(self, undo, *args):
util.test_boolean(undo)
_alen = len(args)
if _alen == 0:
raise ValueError, "No arguments to execute()"
_p = self.getObject()
_op = args[0]
_pts = _p.getPoints()
if _op == 'point_changed':
if _alen < 3:
raise ValueError, "Invalid argument count: %d" % _alen
_oid = args[1]
_nid = args[2]
_parent = _p.getParent()
if _parent is None:
raise ValueError, "Polyline has no parent - cannot undo"
self.ignore(_op)
try:
if undo:
_setpt = _parent.getObject(_oid)
if _setpt is None or not isinstance(_setpt, point.Point):
raise ValueError, "Old endpoint missing: id=%d" % _oid
_p.startUndo()
try:
_seen = False
for _i in range(len(_pts)):
_pt = _pts[_i]
if _pt.getID() == _nid:
_p.setPoint(_i, _setpt)
_seen = True
break
if not _seen:
raise ValueError, "Unexpected point ID: %d" % _nid
finally:
_p.endUndo()
else:
_setpt = _parent.getObject(_nid)
if _setpt is None or not isinstance(_setpt, point.Point):
raise ValueError, "New point missing: id=%d" % _nid
_pts = _p.getPoints()
_p.startRedo()
try:
_seen = False
for _i in range(len(_pts)):
_pt = _pts[_i]
if _pt.getID() == _oid:
_p.setPoint(_i, _setpt)
_seen = True
break
if not _seen:
raise ValueError, "Unexpected point ID: %d" % _nid
finally:
_p.endRedo()
finally:
self.receive(_op)
self.saveData(undo, _op, _oid, _nid)
elif _op == 'added_point':
if _alen < 3:
raise ValueError, "Invalid argument count: %d" % _alen
_idx = args[1]
_pid = args[2]
self.ignore(_op)
try:
if undo:
self.ignore('deleted_point')
try:
_p.startUndo()
try:
_p.delPoint(_idx)
finally:
_p.endUndo()
finally:
self.receive('deleted_point')
else:
_parent = _p.getParent()
if _parent is None:
raise ValueError, "Polyline has no parent - cannot undo"
_pt = _parent.getObject(_pid)
if _pt is None or not isinstance(_pt, point.Point):
raise ValueError, "Point missing: id=%d" % _pid
_p.startRedo()
try:
_p.addPoint(_idx, _pt)
finally:
_p.endRedo()
finally:
self.receive(_op)
self.saveData(undo, _op, _idx, _pid)
elif _op == 'deleted_point':
if _alen < 3:
raise ValueError, "Invalid argument count: %d" % _alen
_idx = args[1]
_pid = args[2]
self.ignore(_op)
try:
if undo:
_parent = _p.getParent()
if _parent is None:
raise ValueError, "Polyline has no parent - cannot undo"
_pt = _parent.getObject(_pid)
if _pt is None or not isinstance(_pt, point.Point):
raise ValueError, "Point missing: id=%d" % _pid
self.ignore('added_point')
try:
_p.startUndo()
try:
_p.addPoint(_idx, _pt)
finally:
_p.endUndo()
finally:
self.receive('added_point')
else:
_p.startRedo()
try:
_p.delPoint(_idx)
finally:
_p.endRedo()
finally:
self.receive(_op)
self.saveData(undo, _op, _idx, _pid)
else:
super(PolylineLog, self).execute(undo, *args)
def execute(self, undo, *args):
util.test_boolean(undo)
_alen = len(args)
if len(args) == 0:
raise ValueError, "No arguments to execute()"
_obj = self.getObject()
_op = args[0]
_image = None
_layer = _obj.getParent()
if _layer is not None:
_image = _layer.getParent()
if _op == 'style_changed':
if _image is None:
raise RuntimeError, "Object not stored in an Image"
if _alen < 2:
raise ValueError, "Invalid argument count: %d" % _alen
_style = None
_sv, _olt, _oc, _ot = args[1]
_name, _ltdata, _col, _th = _sv
for _s in _image.getImageEntities('style'):
if _s.getName() != _name:
continue
_lt = _s.getLinetype()
if (_lt.getName() != _ltdata[0] or
_lt.getList() != _ltdata[1]):
continue
if _s.getColor().getColors() != _col:
continue
if abs(_s.getThickness() - _th) > 1e-10:
continue
_style = _s
break
_sdata = _obj.getGraphicValues()
if _style is not None:
self.ignore(_op)
try:
if undo:
_obj.startUndo()
try:
_obj.setStyle(_style)
finally:
_obj.endUndo()
else:
_obj.startRedo()
try:
_obj.setStyle(_style)
finally:
_obj.endRedo()
finally:
self.receive(_op)
#
# restore values differing from the Style
#
if _olt is not None:
_name, _list = _olt
_lt = None
for _l in _image.getImageEntities('linetype'):
if (_l.getName() == _name and _l.getList() == _list):
_lt = _l
break
_obj.mute()
try:
_obj.setLinetype(_lt)
finally:
_obj.unmute()
if _oc is not None:
_col = None
for _c in _image.getImageEntities('color'):
if _c.getColors() == _oc:
_col = _c
break
_obj.mute()
try:
_obj.setColor(_col)
finally:
_obj.unmute()
if _ot is not None:
_obj.mute()
try:
_obj.setThickness(_ot)
finally:
_obj.unmute()
self.saveData(undo, _op, _sdata)
elif _op == 'linetype_changed':
if _image is None:
raise RuntimeError, "Object not stored in an Image"
if _alen < 2:
raise ValueError, "Invalid argument count: %d" % _alen
_lt = _obj.getLinetype()
_sdata = (_lt.getName(), _lt.getList())
self.ignore(_op)
try:
_name, _list = args[1]
_lt = None
for _l in _image.getImageEntities('linetype'):
if (_l.getName() == _name and _l.getList() == _list):
_lt = _l
break
if undo:
_obj.startUndo()
try:
_obj.setLinetype(_lt)
finally:
_obj.endUndo()
else:
_obj.startRedo()
try:
_obj.setLinetype(_lt)
finally:
_obj.endRedo()
finally:
self.receive(_op)
self.saveData(undo, _op, _sdata)
elif _op == 'color_changed':
if _image is None:
raise RuntimeError, "Object not stored in an Image"
if _alen < 2:
raise ValueError, "Invalid argument count: %d" % _alen
_sdata = _obj.getColor().getColors()
self.ignore(_op)
try:
_col = None
for _c in _image.getImageEntities('color'):
if _c.getColors() == args[1]:
_col = _c
break
if undo:
_obj.startUndo()
try:
_obj.setColor(_col)
finally:
_obj.endUndo()
else:
_obj.startRedo()
try:
_obj.setColor(_col)
finally:
_obj.endRedo()
finally:
self.receive(_op)
self.saveData(undo, _op, _sdata)
elif _op == 'thickness_changed':
if _alen < 2:
raise ValueError, "Invalid argument count: %d" % _alen
_sdata = _obj.getThickness()
self.ignore(_op)
try:
_t = args[1]
if undo:
_obj.startUndo()
try:
_obj.setThickness(_t)
finally:
_obj.endUndo()
else:
_obj.startRedo()
try:
_obj.setThickness(_t)
finally:
_obj.endRedo()
finally:
self.receive(_op)
self.saveData(undo, _op, _sdata)
else:
super(GraphicObjectLog, self).execute(undo, *args)
def execute(self, undo, *args):
util.test_boolean(undo)
_alen = len(args)
if _alen == 0:
raise ValueError, "No arguments to execute()"
_p = self.getObject()
_op = args[0]
_pts = _p.getPoints()
if _op == 'point_changed':
if _alen < 3:
raise ValueError, "Invalid argument count: %d" % _alen
_oid = args[1]
_nid = args[2]
_parent = _p.getParent()
if _parent is None:
raise ValueError, "Polyline has no parent - cannot undo"
self.ignore(_op)
try:
if undo:
_setpt = _parent.getObject(_oid)
if _setpt is None or not isinstance(_setpt, point.Point):
raise ValueError, "Old endpoint missing: id=%d" % _oid
_p.startUndo()
try:
_seen = False
for _i in range(len(_pts)):
_pt = _pts[_i]
if _pt.getID() == _nid:
_p.setPoint(_i, _setpt)
_seen = True
break
if not _seen:
raise ValueError, "Unexpected point ID: %d" % _nid
finally:
_p.endUndo()
else:
_setpt = _parent.getObject(_nid)
if _setpt is None or not isinstance(_setpt, point.Point):
raise ValueError, "New point missing: id=%d" % _nid
_pts = _p.getPoints()
_p.startRedo()
try:
_seen = False
for _i in range(len(_pts)):
_pt = _pts[_i]
if _pt.getID() == _oid:
_p.setPoint(_i, _setpt)
_seen = True
break
if not _seen:
raise ValueError, "Unexpected point ID: %d" % _nid
finally:
_p.endRedo()
finally:
self.receive(_op)
self.saveData(undo, _op, _oid, _nid)
elif _op == 'added_point':
if _alen < 3:
raise ValueError, "Invalid argument count: %d" % _alen
_idx = args[1]
_pid = args[2]
self.ignore(_op)
try:
if undo:
self.ignore('deleted_point')
try:
_p.startUndo()
try:
_p.delPoint(_idx)
finally:
_p.endUndo()
finally:
self.receive('deleted_point')
else:
_parent = _p.getParent()
if _parent is None:
raise ValueError, "Polyline has no parent - cannot undo"
_pt = _parent.getObject(_pid)
if _pt is None or not isinstance(_pt, point.Point):
raise ValueError, "Point missing: id=%d" % _pid
_p.startRedo()
try:
_p.addPoint(_idx, _pt)
finally:
_p.endRedo()
finally:
self.receive(_op)
self.saveData(undo, _op, _idx, _pid)
elif _op == 'deleted_point':
if _alen < 3:
raise ValueError, "Invalid argument count: %d" % _alen
_idx = args[1]
_pid = args[2]
self.ignore(_op)
try:
if undo:
_parent = _p.getParent()
if _parent is None:
raise ValueError, "Polyline has no parent - cannot undo"
_pt = _parent.getObject(_pid)
if _pt is None or not isinstance(_pt, point.Point):
raise ValueError, "Point missing: id=%d" % _pid
self.ignore('added_point')
try:
_p.startUndo()
try:
_p.addPoint(_idx, _pt)
finally:
_p.endUndo()
finally:
self.receive('added_point')
else:
_p.startRedo()
try:
_p.delPoint(_idx)
finally:
_p.endRedo()
finally:
self.receive(_op)
self.saveData(undo, _op, _idx, _pid)
else:
super(PolylineLog, self).execute(undo, *args)
def inRegion(self, xmin, ymin, xmax, ymax, fully=False):
"""Return whether or not an Arc exists within a region.
inRegion(xmin, ymin, xmax, ymax[, fully])
The first four arguments define the boundary. The optional
fifth argument fully indicates whether or not the Arc
must be completely contained within the region or just pass
through it.
"""
_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)
_xc, _yc = self.__center.getCoords()
_r = self.__radius
#
# cheap test to see if arc cannot be in region
#
_axmin, _aymin, _axmax, _aymax = self.getBounds()
if ((_axmin > _xmax) or
(_aymin > _ymax) or
(_axmax < _xmin) or
(_aymax < _ymin)):
return False
_val = False
_bits = 0
#
# calculate distances from center to region boundary
#
if abs(_xc - _xmin) < _r: _bits = _bits | 1 # left edge
if abs(_xc - _xmax) < _r: _bits = _bits | 2 # right edge
if abs(_yc - _ymin) < _r: _bits = _bits | 4 # bottom edge
if abs(_yc - _ymax) < _r: _bits = _bits | 8 # top edge
if _bits == 0:
#
# arc must be visible - the center is in
# the region and is more than the radius from
# each edge
#
_val = True
else:
#
# calculate distance to corners of region
#
if math.hypot((_xc - _xmin), (_yc - _ymax)) < _r:
_bits = _bits | 0x10 # upper left
if math.hypot((_xc - _xmax), (_yc - _ymin)) < _r:
_bits = _bits | 0x20 # lower right
if math.hypot((_xc - _xmin), (_yc - _ymin)) < _r:
_bits = _bits | 0x40 # lower left
if math.hypot((_xc - _xmax), (_yc - _ymax)) < _r:
_bits = _bits | 0x80 # upper right
#
# if all bits are set then distance from arc center
# to region endpoints is less than radius - arc
# entirely outside the region
#
_val = not ((_bits == 0xff) or fully)
#
# if the test value is still true, check that the
# arc boundary can overlap with the region
#
if _val:
_ep1, _ep2 = self.getEndpoints()
_axmin = min(_xc, _ep1[0], _ep2[0])
if self.throughAngle(180.0):
_axmin = _xc - _r
if _axmin > _xmax:
return False
_aymin = min(_yc, _ep1[1], _ep2[1])
if self.throughAngle(270.0):
_aymin = _yc - _r
if _aymin > _ymax:
return False
_axmax = max(_xc, _ep1[0], _ep2[0])
if self.throughAngle(0.0):
_axmax = _xc + _r
if _axmax < _xmin:
return False
_aymax = max(_yc, _ep1[1], _ep2[1])
if self.throughAngle(90.0):
_aymax = _yc + _r
if _aymax < _ymin:
return False
return _val
