def action(self, arg):
"""Handle the 3D scene events.
This is installed as an EventCallback in the Inventor view
by the `Activated` method of the parent class.
Parameters
----------
arg: dict
Dictionary with strings that indicates the type of event received
from the 3D view.
"""
if arg["Type"] == "SoKeyboardEvent":
if arg["Key"] == "ESCAPE":
self.finish()
elif arg["Type"] == "SoLocation2Event": # mouse movement detection
(self.point, ctrlPoint,
info) = gui_tool_utils.getPoint(self, arg, noTracker=True)
# existing points + this pointer position
self.bezcurvetrack.update(self.node + [self.point],
degree=self.degree)
gui_tool_utils.redraw3DView()
elif (arg["Type"] == "SoMouseButtonEvent" and arg["State"] == "DOWN"
and arg["Button"] == "BUTTON1"): # left click
if arg["Position"] == self.pos:
self.finish(False, cont=True)
if (not self.node) and (not self.support): # first point
gui_tool_utils.getSupport(arg)
(self.point, ctrlPoint,
info) = gui_tool_utils.getPoint(self, arg, noTracker=True)
if self.point:
self.ui.redraw()
self.pos = arg["Position"]
self.node.append(self.point) # add point to "clicked list"
# sb add a control point,
# if mod(len(cpoints), 2) == 0
# then create 2 handle points?
self.drawUpdate(self.point)
if not self.isWire and len(self.node) == 2:
self.finish(False, cont=True)
if len(self.node) > 2:
# does this make sense for a BCurve?
# DNC: allows to close the curve
# by placing ends close to each other
# with tol = Draft tolerance
# old code has been to insensitive
if (self.point - self.node[0]).Length < utils.tolerance():
self.undolast()
self.finish(True, cont=True)
_msg(translate("draft",
"Bezier curve has been closed"))
def action(self, arg):
"""Handle the 3D scene events.
This is installed as an EventCallback in the Inventor view
by the `Activated` method of the parent class.
Parameters
----------
arg: dict
Dictionary with strings that indicates the type of event received
from the 3D view.
"""
if arg["Type"] == "SoKeyboardEvent":
if arg["Key"] == "ESCAPE":
self.finish()
elif arg["Type"] == "SoLocation2Event": # mouse movement detection
(self.point,
ctrlPoint, info) = gui_tool_utils.getPoint(self, arg,
noTracker=True)
self.bsplinetrack.update(self.node + [self.point])
gui_tool_utils.redraw3DView()
elif (arg["Type"] == "SoMouseButtonEvent"
and arg["State"] == "DOWN"
and arg["Button"] == "BUTTON1"):
if arg["Position"] == self.pos:
self.finish(False, cont=True)
if (not self.node) and (not self.support):
gui_tool_utils.getSupport(arg)
(self.point,
ctrlPoint, info) = gui_tool_utils.getPoint(self, arg,
noTracker=True)
if self.point:
self.ui.redraw()
self.pos = arg["Position"]
self.node.append(self.point)
self.drawUpdate(self.point)
if not self.isWire and len(self.node) == 2:
self.finish(False, cont=True)
if len(self.node) > 2:
# DNC: allows to close the curve
# by placing ends close to each other
# with tol = Draft tolerance
# old code has been to insensitive
if (self.point - self.node[0]).Length < utils.tolerance():
self.undolast()
self.finish(True, cont=True)
_msg(translate("draft",
"Spline has been closed"))
def action(self, arg):
"""Handle the 3D scene events.
This is installed as an EventCallback in the Inventor view.
Parameters
----------
arg: dict
Dictionary with strings that indicates the type of event received
from the 3D view.
"""
if arg["Type"] == "SoKeyboardEvent":
if arg["Key"] == "ESCAPE":
self.finish()
elif arg["Type"] == "SoLocation2Event": # mouse movement detection
if self.active:
(self.point, ctrlPoint,
info) = gui_tool_utils.getPoint(self, arg)
gui_tool_utils.redraw3DView()
elif arg["Type"] == "SoMouseButtonEvent":
if arg["State"] == "DOWN" and arg["Button"] == "BUTTON1":
if self.point:
self.active = False
Gui.Snapper.off()
self.node.append(self.point)
self.ui.textUi()
self.ui.textValue.setFocus()
def handle_mouse_move_event(self, arg):
"""Handle the mouse event of movement."""
for ghost in self.ghosts:
ghost.off()
(self.point, ctrlPoint, info) = gui_tool_utils.getPoint(self,
arg,
sym=True)
def action(self, arg):
"""Handle the 3D scene events.
This is installed as an EventCallback in the Inventor view.
Parameters
----------
arg: dict
Dictionary with strings that indicates the type of event received
from the 3D view.
"""
if arg["Type"] == "SoKeyboardEvent":
if arg["Key"] == "ESCAPE":
self.finish()
elif arg["Type"] == "SoLocation2Event": # mouse movement detection
self.shift = gui_tool_utils.hasMod(arg,
gui_tool_utils.MODCONSTRAIN)
self.alt = gui_tool_utils.hasMod(arg, gui_tool_utils.MODALT)
self.ctrl = gui_tool_utils.hasMod(arg, gui_tool_utils.MODSNAP)
if self.extrudeMode:
arg["ShiftDown"] = False
elif hasattr(Gui, "Snapper"):
Gui.Snapper.setSelectMode(not self.ctrl)
wp = not (self.extrudeMode and self.shift)
self.point, cp, info = gui_tool_utils.getPoint(self,
arg,
workingplane=wp)
if gui_tool_utils.hasMod(arg, gui_tool_utils.MODSNAP):
self.snapped = None
else:
self.snapped = self.view.getObjectInfo(
(arg["Position"][0], arg["Position"][1]))
if self.extrudeMode:
dist = self.extrude(self.shift)
else:
dist = self.redraw(self.point, self.snapped, self.shift,
self.alt)
self.ui.setRadiusValue(dist, unit="Length")
self.ui.radiusValue.setFocus()
self.ui.radiusValue.selectAll()
gui_tool_utils.redraw3DView()
elif arg["Type"] == "SoMouseButtonEvent":
if (arg["State"] == "DOWN") and (arg["Button"] == "BUTTON1"):
cursor = arg["Position"]
self.shift = gui_tool_utils.hasMod(arg,
gui_tool_utils.MODCONSTRAIN)
self.alt = gui_tool_utils.hasMod(arg, gui_tool_utils.MODALT)
if gui_tool_utils.hasMod(arg, gui_tool_utils.MODSNAP):
self.snapped = None
else:
self.snapped = self.view.getObjectInfo(
(cursor[0], cursor[1]))
self.trimObject()
self.finish()
def action(self, arg):
"""Handle the 3D scene events.
This is installed as an EventCallback in the Inventor view.
Parameters
----------
arg: dict
Dictionary with strings that indicates the type of event received
from the 3D view.
"""
if arg["Type"] == "SoKeyboardEvent" and arg["Key"] == "ESCAPE":
self.finish()
elif arg["Type"] == "SoLocation2Event":
self.point, ctrlPoint, info = gui_tool_utils.getPoint(self, arg)
gui_tool_utils.redraw3DView()
elif (arg["Type"] == "SoMouseButtonEvent"
and arg["State"] == "DOWN"
and arg["Button"] == "BUTTON1"):
if arg["Position"] == self.pos:
return self.finish(False, cont=True)
if (not self.node) and (not self.support):
gui_tool_utils.getSupport(arg)
(self.point,
ctrlPoint, info) = gui_tool_utils.getPoint(self, arg)
if self.point:
self.ui.redraw()
self.pos = arg["Position"]
self.node.append(self.point)
self.drawSegment(self.point)
if not self.isWire and len(self.node) == 2:
self.finish(False, cont=True)
if len(self.node) > 2:
# The wire is closed
if (self.point - self.node[0]).Length < utils.tolerance():
self.undolast()
if len(self.node) > 2:
self.finish(True, cont=True)
else:
self.finish(False, cont=True)
def action(self, arg):
"""Scene event handler. CURRENTLY NOT USED.
Here the displaying of the trackers (previews)
should be implemented by considering the current value of the
`ui.radiusValue`.
"""
if arg["Type"] == "SoKeyboardEvent":
if arg["Key"] == "ESCAPE":
self.finish()
elif arg["Type"] == "SoLocation2Event":
self.point, ctrlPoint, info = gui_tool_utils.getPoint(self, arg)
gui_tool_utils.redraw3DView()
def action(self, arg):
"""Handle the 3D scene events.
This is installed as an EventCallback in the Inventor view.
Parameters
----------
arg: dict
Dictionary with strings that indicates the type of event received
from the 3D view.
"""
if arg["Type"] == "SoKeyboardEvent":
if arg["Key"] == "ESCAPE":
self.finish()
elif arg["Type"] == "SoLocation2Event":
gui_tool_utils.getPoint(self, arg)
gui_tool_utils.redraw3DView()
elif (arg["Type"] == "SoMouseButtonEvent"
and arg["Button"] == "BUTTON1" and arg["State"] == "DOWN"):
self.point, ctrlPoint, info = gui_tool_utils.getPoint(self, arg)
if "Edge" in info["Component"]:
return self.proceed(info)
def handle_mouse_move_event(self, arg):
"""Handle the mouse when moving."""
plane = App.DraftWorkingPlane
for ghost in self.ghosts:
ghost.off()
self.point, ctrlPoint, info = gui_tool_utils.getPoint(self, arg)
# this is to make sure radius is what you see on screen
if self.center and DraftVecUtils.dist(self.point, self.center):
viewdelta = DraftVecUtils.project(self.point.sub(self.center),
plane.axis)
if not DraftVecUtils.isNull(viewdelta):
self.point = self.point.add(viewdelta.negative())
if self.extendedCopy:
if not gui_tool_utils.hasMod(arg, gui_tool_utils.MODALT):
self.step = 3
self.finish()
if self.step == 0:
pass
elif self.step == 1:
currentrad = DraftVecUtils.dist(self.point, self.center)
if currentrad != 0:
angle = DraftVecUtils.angle(plane.u,
self.point.sub(self.center),
plane.axis)
else:
angle = 0
self.ui.setRadiusValue(math.degrees(angle), unit="Angle")
self.firstangle = angle
self.ui.radiusValue.setFocus()
self.ui.radiusValue.selectAll()
elif self.step == 2:
currentrad = DraftVecUtils.dist(self.point, self.center)
if currentrad != 0:
angle = DraftVecUtils.angle(plane.u,
self.point.sub(self.center),
plane.axis)
else:
angle = 0
if angle < self.firstangle:
sweep = (2 * math.pi - self.firstangle) + angle
else:
sweep = angle - self.firstangle
self.arctrack.setApertureAngle(sweep)
for ghost in self.ghosts:
ghost.rotate(plane.axis, sweep)
ghost.on()
self.ui.setRadiusValue(math.degrees(sweep), 'Angle')
self.ui.radiusValue.setFocus()
self.ui.radiusValue.selectAll()
gui_tool_utils.redraw3DView()
def action(self, arg):
"""Handle the 3D scene events.
This is installed as an EventCallback in the Inventor view.
Parameters
----------
arg: dict
Dictionary with strings that indicates the type of event received
from the 3D view.
"""
if arg["Type"] == "SoKeyboardEvent":
if arg["Key"] == "ESCAPE":
self.finish()
elif arg["Type"] == "SoLocation2Event": # mouse movement detection
(self.point, ctrlPoint,
info) = gui_tool_utils.getPoint(self,
arg,
mobile=True,
noTracker=True)
self.rect.update(self.point)
gui_tool_utils.redraw3DView()
elif (arg["Type"] == "SoMouseButtonEvent" and arg["State"] == "DOWN"
and arg["Button"] == "BUTTON1"):
if arg["Position"] == self.pos:
self.finish()
if (not self.node) and (not self.support):
gui_tool_utils.getSupport(arg)
(self.point, ctrlPoint,
info) = gui_tool_utils.getPoint(self,
arg,
mobile=True,
noTracker=True)
if self.point:
self.ui.redraw()
self.appendPoint(self.point)
def action(self, arg):
"""scene event handler"""
if arg["Type"] == "SoKeyboardEvent":
if arg["Key"] == "ESCAPE":
self.reject()
elif arg["Type"] == "SoLocation2Event": # mouse movement detection
self.point, ctrlPoint, info = gui_tool_utils.getPoint(
self.sourceCmd, arg, noTracker=True)
if not self.pointPicked:
self.setPoint(self.point)
elif arg["Type"] == "SoMouseButtonEvent":
if (arg["State"] == "DOWN") and (arg["Button"] == "BUTTON1"):
self.setPoint(self.point)
self.pointPicked = True
def handle_mouse_move_event(self, arg):
"""Handle the mouse when moving."""
for ghost in self.ghosts:
ghost.off()
self.point, ctrlPoint, info = gui_tool_utils.getPoint(self, arg)
if len(self.node) > 0:
last = self.node[len(self.node) - 1]
self.vector = self.point.sub(last)
for ghost in self.ghosts:
ghost.move(self.vector)
ghost.on()
if self.extendedCopy:
if not gui_tool_utils.hasMod(arg, gui_tool_utils.MODALT):
self.finish()
gui_tool_utils.redraw3DView()
def action(self, arg):
"""Handle the 3D scene events.
This is installed as an EventCallback in the Inventor view.
Parameters
----------
arg: dict
Dictionary with strings that indicates the type of event received
from the 3D view.
"""
if arg["Type"] == "SoKeyboardEvent":
if arg["Key"] == "ESCAPE":
self.finish()
elif arg["Type"] == "SoLocation2Event":
if hasattr(Gui, "Snapper"):
Gui.Snapper.affinity = None # don't keep affinity
if len(self.node) == 2:
gui_tool_utils.setMod(arg, gui_tool_utils.MODCONSTRAIN, True)
self.point, ctrlPoint, info = gui_tool_utils.getPoint(self, arg)
gui_tool_utils.redraw3DView()
elif arg["Type"] == "SoMouseButtonEvent":
if (arg["State"] == "DOWN") and (arg["Button"] == "BUTTON1"):
if self.point:
self.ui.redraw()
if not self.node:
# first click
self.node.append(self.point)
self.ui.isRelative.show()
_msg(translate("draft",
"Pick endpoint of leader line"))
if self.planetrack:
self.planetrack.set(self.point)
elif len(self.node) == 1:
# second click
self.node.append(self.point)
if self.ghost:
self.ghost.p1(self.node[0])
self.ghost.p2(self.node[1])
self.ghost.on()
_msg(translate("draft", "Pick text position"))
else:
# third click
self.node.append(self.point)
self.create()
def action(self, arg):
"""Handle the 3D scene events.
This is installed as an EventCallback in the Inventor view.
Parameters
----------
arg: dict
Dictionary with strings that indicates the type of event received
from the 3D view.
"""
import DraftGeomUtils
if arg["Type"] == "SoKeyboardEvent":
if arg["Key"] == "ESCAPE":
self.finish()
elif arg["Type"] == "SoLocation2Event": # mouse movement detection
self.point, ctrlPoint, info = gui_tool_utils.getPoint(self, arg)
# this is to make sure radius is what you see on screen
if self.center and DraftVecUtils.dist(self.point, self.center) > 0:
viewdelta = DraftVecUtils.project(self.point.sub(self.center),
App.DraftWorkingPlane.axis)
if not DraftVecUtils.isNull(viewdelta):
self.point = self.point.add(viewdelta.negative())
if self.step == 0: # choose center
if gui_tool_utils.hasMod(arg, gui_tool_utils.MODALT):
if not self.altdown:
self.altdown = True
self.ui.switchUi(True)
else:
if self.altdown:
self.altdown = False
self.ui.switchUi(False)
else: # choose radius
if len(self.tangents) == 2:
cir = DraftGeomUtils.circleFrom2tan1pt(
self.tangents[0], self.tangents[1], self.point)
_c = DraftGeomUtils.findClosestCircle(self.point, cir)
self.center = _c.Center
self.arctrack.setCenter(self.center)
elif self.tangents and self.tanpoints:
cir = DraftGeomUtils.circleFrom1tan2pt(
self.tangents[0], self.tanpoints[0], self.point)
_c = DraftGeomUtils.findClosestCircle(self.point, cir)
self.center = _c.Center
self.arctrack.setCenter(self.center)
if gui_tool_utils.hasMod(arg, gui_tool_utils.MODALT):
if not self.altdown:
self.altdown = True
snapped = self.view.getObjectInfo(
(arg["Position"][0], arg["Position"][1]))
if snapped:
ob = self.doc.getObject(snapped['Object'])
num = int(snapped['Component'].lstrip('Edge')) - 1
ed = ob.Shape.Edges[num]
if len(self.tangents) == 2:
cir = DraftGeomUtils.circleFrom3tan(
self.tangents[0], self.tangents[1], ed)
cl = DraftGeomUtils.findClosestCircle(
self.point, cir)
self.center = cl.Center
self.rad = cl.Radius
self.arctrack.setCenter(self.center)
else:
self.rad = self.center.add(
DraftGeomUtils.findDistance(
self.center, ed).sub(self.center)).Length
else:
self.rad = DraftVecUtils.dist(self.point, self.center)
else:
if self.altdown:
self.altdown = False
self.rad = DraftVecUtils.dist(self.point, self.center)
self.ui.setRadiusValue(self.rad, 'Length')
self.arctrack.setRadius(self.rad)
gui_tool_utils.redraw3DView()
elif (arg["Type"] == "SoMouseButtonEvent" and arg["State"] == "DOWN"
and arg["Button"] == "BUTTON1"): # mouse click
if self.point:
if self.step == 0: # choose center
if (not self.node) and (not self.support):
gui_tool_utils.getSupport(arg)
(self.point, ctrlPoint,
info) = gui_tool_utils.getPoint(self, arg)
if gui_tool_utils.hasMod(arg, gui_tool_utils.MODALT):
snapped = self.view.getObjectInfo(
(arg["Position"][0], arg["Position"][1]))
if snapped:
ob = self.doc.getObject(snapped['Object'])
num = int(snapped['Component'].lstrip('Edge')) - 1
ed = ob.Shape.Edges[num]
self.tangents.append(ed)
if len(self.tangents) == 2:
self.arctrack.on()
self.ui.radiusUi()
self.step = 1
_msg(translate("draft", "Pick radius"))
else:
if len(self.tangents) == 1:
self.tanpoints.append(self.point)
else:
self.center = self.point
self.node = [self.point]
self.arctrack.setCenter(self.center)
self.arctrack.on()
self.ui.radiusUi()
self.step = 1
_msg(translate("draft", "Pick radius"))
if self.planetrack:
self.planetrack.set(self.point)
elif self.step == 1: # choose radius
self.drawPolygon()
def action(self, arg):
"""Handle the 3D scene events.
This is installed as an EventCallback in the Inventor view.
Parameters
----------
arg: dict
Dictionary with strings that indicates the type of event received
from the 3D view.
"""
import DraftGeomUtils
plane = App.DraftWorkingPlane
if arg["Type"] == "SoKeyboardEvent":
if arg["Key"] == "ESCAPE":
self.finish()
elif arg["Type"] == "SoLocation2Event":
self.point, ctrlPoint, info = gui_tool_utils.getPoint(self, arg)
if (gui_tool_utils.hasMod(arg, gui_tool_utils.MODCONSTRAIN)
and self.constrainSeg):
dist = DraftGeomUtils.findPerpendicular(self.point,
self.shape,
self.constrainSeg[1])
else:
dist = DraftGeomUtils.findPerpendicular(self.point,
self.shape.Edges)
if dist:
self.ghost.on()
if self.mode == "Wire":
d = dist[0].negative()
v1 = DraftGeomUtils.getTangent(self.shape.Edges[0],
self.point)
v2 = DraftGeomUtils.getTangent(self.shape.Edges[dist[1]],
self.point)
a = -DraftVecUtils.angle(v1, v2, plane.axis)
self.dvec = DraftVecUtils.rotate(d, a, plane.axis)
occmode = self.ui.occOffset.isChecked()
utils.param.SetBool("Offset_OCC", occmode)
_wire = DraftGeomUtils.offsetWire(self.shape,
self.dvec,
occ=occmode)
self.ghost.update(_wire, forceclosed=occmode)
elif self.mode == "BSpline":
d = dist[0].negative()
e = self.shape.Edges[0]
basetan = DraftGeomUtils.getTangent(e, self.point)
self.npts = []
for p in self.sel.Points:
currtan = DraftGeomUtils.getTangent(e, p)
a = -DraftVecUtils.angle(currtan, basetan, plane.axis)
self.dvec = DraftVecUtils.rotate(d, a, plane.axis)
self.npts.append(p.add(self.dvec))
self.ghost.update(self.npts)
elif self.mode == "Circle":
self.dvec = self.point.sub(self.center).Length
self.ghost.setRadius(self.dvec)
self.constrainSeg = dist
self.linetrack.on()
self.linetrack.p1(self.point)
self.linetrack.p2(self.point.add(dist[0]))
self.ui.setRadiusValue(dist[0].Length, unit="Length")
else:
self.dvec = None
self.ghost.off()
self.constrainSeg = None
self.linetrack.off()
self.ui.radiusValue.setText("off")
self.ui.radiusValue.setFocus()
self.ui.radiusValue.selectAll()
if self.extendedCopy:
if not gui_tool_utils.hasMod(arg, gui_tool_utils.MODALT):
self.finish()
gui_tool_utils.redraw3DView()
elif arg["Type"] == "SoMouseButtonEvent":
if (arg["State"] == "DOWN") and (arg["Button"] == "BUTTON1"):
copymode = False
occmode = self.ui.occOffset.isChecked()
utils.param.SetBool("Offset_OCC", occmode)
if (gui_tool_utils.hasMod(arg, gui_tool_utils.MODALT)
or self.ui.isCopy.isChecked()):
copymode = True
Gui.addModule("Draft")
if self.npts:
# _msg("offset:npts= " + str(self.npts))
_cmd = 'Draft.offset'
_cmd += '('
_cmd += 'FreeCAD.ActiveDocument.'
_cmd += self.sel.Name + ', '
_cmd += DraftVecUtils.toString(self.npts) + ', '
_cmd += 'copy=' + str(copymode)
_cmd += ')'
_cmd_list = ['offst = ' + _cmd,
'FreeCAD.ActiveDocument.recompute()']
self.commit(translate("draft", "Offset"),
_cmd_list)
elif self.dvec:
if isinstance(self.dvec, float):
delta = str(self.dvec)
else:
delta = DraftVecUtils.toString(self.dvec)
_cmd = 'Draft.offset'
_cmd += '('
_cmd += 'FreeCAD.ActiveDocument.'
_cmd += self.sel.Name + ', '
_cmd += delta + ', '
_cmd += 'copy=' + str(copymode) + ', '
_cmd += 'occ=' + str(occmode)
_cmd += ')'
_cmd_list = ['offst = ' + _cmd,
'FreeCAD.ActiveDocument.recompute()']
self.commit(translate("draft", "Offset"),
_cmd_list)
if gui_tool_utils.hasMod(arg, gui_tool_utils.MODALT):
self.extendedCopy = True
else:
self.finish()
def action(self, arg):
"""Handle the 3D scene events.
This is installed as an EventCallback in the Inventor view
by the `Activated` method of the parent class.
Parameters
----------
arg: dict
Dictionary with strings that indicates the type of event received
from the 3D view.
"""
if arg["Type"] == "SoKeyboardEvent":
if arg["Key"] == "ESCAPE":
self.finish()
elif arg["Type"] == "SoLocation2Event": # mouse movement detection
(self.point,
ctrlPoint, info) = gui_tool_utils.getPoint(self, arg,
noTracker=True)
if (len(self.node) - 1) % self.degree == 0 and len(self.node) > 2:
prevctrl = 2 * self.node[-1] - self.point
# Existing points + this pointer position
self.bezcurvetrack.update(self.node[0:-2]
+ [prevctrl]
+ [self.node[-1]]
+ [self.point], degree=self.degree)
else:
# Existing points + this pointer position
self.bezcurvetrack.update(self.node
+ [self.point], degree=self.degree)
gui_tool_utils.redraw3DView()
elif arg["Type"] == "SoMouseButtonEvent":
# Press and hold the button
if arg["State"] == "DOWN" and arg["Button"] == "BUTTON1":
if arg["Position"] == self.pos:
if len(self.node) > 2:
self.node = self.node[0:-2]
else:
self.node = []
return
else:
if (not self.node) and (not self.support): # first point
gui_tool_utils.getSupport(arg)
(self.point,
ctrlPoint,
info) = gui_tool_utils.getPoint(self, arg,
noTracker=True)
if self.point:
self.ui.redraw()
self.pos = arg["Position"]
# add point to "clicked list"
self.node.append(self.point)
# sb add a control point,
# if mod(len(cpoints), 2) == 0
# then create 2 handle points?
self.drawUpdate(self.point)
if not self.isWire and len(self.node) == 2:
self.finish(False, cont=True)
# does this make sense for a BCurve?
if len(self.node) > 2:
# add point to "clicked list"
self.node.append(self.point)
self.drawUpdate(self.point)
# DNC: allows to close the curve
# by placing ends close to each other
# with tol = Draft tolerance
# old code has been to insensitive
_diff = (self.point - self.node[0]).Length
if (_diff < utils.tolerance()
and len(self.node) >= 4):
# self.undolast()
self.node = self.node[0:-2]
# close the curve with a smooth symmetric knot
_sym = 2 * self.node[0] - self.node[1]
self.node.append(_sym)
self.finish(True, cont=True)
_msg(translate("draft",
"Bezier curve has been closed"))
# Release the held button
if arg["State"] == "UP" and arg["Button"] == "BUTTON1":
if arg["Position"] == self.pos:
self.node = self.node[0:-2]
return
else:
if (not self.node) and (not self.support): # first point
return
if self.point:
self.ui.redraw()
self.pos = arg["Position"]
# add point to "clicked list"
self.node.append(self.point)
# sb add a control point,
# if mod(len(cpoints),2) == 0
# then create 2 handle points?
self.drawUpdate(self.point)
if not self.isWire and len(self.node) == 2:
self.finish(False, cont=True)
# Does this make sense for a BCurve?
if len(self.node) > 2:
self.node[-3] = 2 * self.node[-2] - self.node[-1]
self.drawUpdate(self.point)
def action(self, arg):
"""Handle the 3D scene events.
This is installed as an EventCallback in the Inventor view.
Parameters
----------
arg: dict
Dictionary with strings that indicates the type of event received
from the 3D view.
"""
import DraftGeomUtils
plane = App.DraftWorkingPlane
if arg["Type"] == "SoKeyboardEvent":
if arg["Key"] == "ESCAPE":
self.finish()
elif arg["Type"] == "SoLocation2Event": # mouse movement detection
self.point, ctrlPoint, info = gui_tool_utils.getPoint(self, arg)
# this is to make sure radius is what you see on screen
if self.center and DraftVecUtils.dist(self.point, self.center) > 0:
viewdelta = DraftVecUtils.project(self.point.sub(self.center),
plane.axis)
if not DraftVecUtils.isNull(viewdelta):
self.point = self.point.add(viewdelta.negative())
if self.step == 0: # choose center
if gui_tool_utils.hasMod(arg, gui_tool_utils.MODALT):
if not self.altdown:
self.altdown = True
self.ui.switchUi(True)
else:
if self.altdown:
self.altdown = False
self.ui.switchUi(False)
elif self.step == 1: # choose radius
if len(self.tangents) == 2:
cir = DraftGeomUtils.circleFrom2tan1pt(self.tangents[0],
self.tangents[1],
self.point)
_c = DraftGeomUtils.findClosestCircle(self.point, cir)
self.center = _c.Center
self.arctrack.setCenter(self.center)
elif self.tangents and self.tanpoints:
cir = DraftGeomUtils.circleFrom1tan2pt(self.tangents[0],
self.tanpoints[0],
self.point)
_c = DraftGeomUtils.findClosestCircle(self.point, cir)
self.center = _c.Center
self.arctrack.setCenter(self.center)
if gui_tool_utils.hasMod(arg, gui_tool_utils.MODALT):
if not self.altdown:
self.altdown = True
if info:
ob = self.doc.getObject(info['Object'])
num = int(info['Component'].lstrip('Edge')) - 1
ed = ob.Shape.Edges[num]
if len(self.tangents) == 2:
cir = DraftGeomUtils.circleFrom3tan(self.tangents[0],
self.tangents[1],
ed)
cl = DraftGeomUtils.findClosestCircle(self.point, cir)
self.center = cl.Center
self.rad = cl.Radius
self.arctrack.setCenter(self.center)
else:
self.rad = self.center.add(DraftGeomUtils.findDistance(self.center, ed).sub(self.center)).Length
else:
self.rad = DraftVecUtils.dist(self.point, self.center)
else:
if self.altdown:
self.altdown = False
self.rad = DraftVecUtils.dist(self.point, self.center)
self.ui.setRadiusValue(self.rad, "Length")
self.arctrack.setRadius(self.rad)
self.linetrack.p1(self.center)
self.linetrack.p2(self.point)
self.linetrack.on()
elif (self.step == 2): # choose first angle
currentrad = DraftVecUtils.dist(self.point, self.center)
if currentrad != 0:
angle = DraftVecUtils.angle(plane.u, self.point.sub(self.center), plane.axis)
else:
angle = 0
self.linetrack.p2(DraftVecUtils.scaleTo(self.point.sub(self.center), self.rad).add(self.center))
self.ui.setRadiusValue(math.degrees(angle), unit="Angle")
self.firstangle = angle
else:
# choose second angle
currentrad = DraftVecUtils.dist(self.point, self.center)
if currentrad != 0:
angle = DraftVecUtils.angle(plane.u, self.point.sub(self.center), plane.axis)
else:
angle = 0
self.linetrack.p2(DraftVecUtils.scaleTo(self.point.sub(self.center), self.rad).add(self.center))
self.updateAngle(angle)
self.ui.setRadiusValue(math.degrees(self.angle), unit="Angle")
self.arctrack.setApertureAngle(self.angle)
gui_tool_utils.redraw3DView()
elif arg["Type"] == "SoMouseButtonEvent": # mouse click
if arg["State"] == "DOWN" and arg["Button"] == "BUTTON1":
if self.point:
if self.step == 0: # choose center
if not self.support:
gui_tool_utils.getSupport(arg)
(self.point,
ctrlPoint, info) = gui_tool_utils.getPoint(self, arg)
if gui_tool_utils.hasMod(arg, gui_tool_utils.MODALT):
snapped = self.view.getObjectInfo((arg["Position"][0],
arg["Position"][1]))
if snapped:
ob = self.doc.getObject(snapped['Object'])
num = int(snapped['Component'].lstrip('Edge')) - 1
ed = ob.Shape.Edges[num]
self.tangents.append(ed)
if len(self.tangents) == 2:
self.arctrack.on()
self.ui.radiusUi()
self.step = 1
self.ui.setNextFocus()
self.linetrack.on()
_msg(translate("draft", "Pick radius"))
else:
if len(self.tangents) == 1:
self.tanpoints.append(self.point)
else:
self.center = self.point
self.node = [self.point]
self.arctrack.setCenter(self.center)
self.linetrack.p1(self.center)
self.linetrack.p2(self.view.getPoint(arg["Position"][0],
arg["Position"][1]))
self.arctrack.on()
self.ui.radiusUi()
self.step = 1
self.ui.setNextFocus()
self.linetrack.on()
_msg(translate("draft", "Pick radius"))
if self.planetrack:
self.planetrack.set(self.point)
elif self.step == 1: # choose radius
if self.closedCircle:
self.drawArc()
else:
self.ui.labelRadius.setText(translate("draft", "Start angle"))
self.ui.radiusValue.setToolTip(translate("draft", "Start angle"))
self.ui.radiusValue.setText(U.Quantity(0, U.Angle).UserString)
self.linetrack.p1(self.center)
self.linetrack.on()
self.step = 2
_msg(translate("draft", "Pick start angle"))
elif self.step == 2: # choose first angle
self.ui.labelRadius.setText(translate("draft", "Aperture angle"))
self.ui.radiusValue.setToolTip(translate("draft", "Aperture angle"))
self.step = 3
# scale center->point vector for proper display
# u = DraftVecUtils.scaleTo(self.point.sub(self.center), self.rad) obsolete?
self.arctrack.setStartAngle(self.firstangle)
_msg(translate("draft", "Pick aperture"))
else: # choose second angle
self.step = 4
self.drawArc()
def action(self, arg):
"""Handle the 3D scene events.
This is installed as an EventCallback in the Inventor view.
Parameters
----------
arg: dict
Dictionary with strings that indicates the type of event received
from the 3D view.
"""
if arg["Type"] == "SoKeyboardEvent":
if arg["Key"] == "ESCAPE":
self.finish()
elif arg["Type"] == "SoLocation2Event": # mouse movement detection
import DraftGeomUtils
shift = gui_tool_utils.hasMod(arg, gui_tool_utils.MODCONSTRAIN)
if self.arcmode or self.point2:
gui_tool_utils.setMod(arg, gui_tool_utils.MODCONSTRAIN, False)
(self.point, ctrlPoint, self.info) = gui_tool_utils.getPoint(
self, arg, noTracker=(len(self.node) > 0))
if (gui_tool_utils.hasMod(arg, gui_tool_utils.MODALT)
or self.selectmode) and (len(self.node) < 3):
self.dimtrack.off()
if not self.altdown:
self.altdown = True
self.ui.switchUi(True)
if hasattr(Gui, "Snapper"):
Gui.Snapper.setSelectMode(True)
snapped = self.view.getObjectInfo(
(arg["Position"][0], arg["Position"][1]))
if snapped:
ob = self.doc.getObject(snapped['Object'])
if "Edge" in snapped['Component']:
num = int(snapped['Component'].lstrip('Edge')) - 1
ed = ob.Shape.Edges[num]
v1 = ed.Vertexes[0].Point
v2 = ed.Vertexes[-1].Point
self.dimtrack.update([v1, v2, self.cont])
else:
if self.node and (len(self.edges) < 2):
self.dimtrack.on()
if len(self.edges) == 2:
# angular dimension
self.dimtrack.off()
r = self.point.sub(self.center)
self.arctrack.setRadius(r.Length)
a = self.arctrack.getAngle(self.point)
pair = DraftGeomUtils.getBoundaryAngles(a, self.pts)
if not (pair[0] < a < pair[1]):
self.angledata = [
4 * math.pi - pair[0], 2 * math.pi - pair[1]
]
else:
self.angledata = [
2 * math.pi - pair[0], 2 * math.pi - pair[1]
]
self.arctrack.setStartAngle(self.angledata[0])
self.arctrack.setEndAngle(self.angledata[1])
if self.altdown:
self.altdown = False
self.ui.switchUi(False)
if hasattr(Gui, "Snapper"):
Gui.Snapper.setSelectMode(False)
if self.dir:
_p = DraftVecUtils.project(self.point.sub(self.node[0]),
self.dir)
self.point = self.node[0].add(_p)
if len(self.node) == 2:
if self.arcmode and self.edges:
cen = self.edges[0].Curve.Center
rad = self.edges[0].Curve.Radius
baseray = self.point.sub(cen)
v2 = DraftVecUtils.scaleTo(baseray, rad)
v1 = v2.negative()
if shift:
self.node = [cen, cen.add(v2)]
self.arcmode = "radius"
else:
self.node = [cen.add(v1), cen.add(v2)]
self.arcmode = "diameter"
self.dimtrack.update(self.node)
# Draw constraint tracker line.
if shift and (not self.arcmode):
if len(self.node) == 2:
if not self.point2:
self.point2 = self.node[1]
else:
self.node[1] = self.point2
if not self.force:
_p = self.point.sub(self.node[0])
a = abs(_p.getAngle(App.DraftWorkingPlane.u))
if (a > math.pi / 4) and (a <= 0.75 * math.pi):
self.force = 1
else:
self.force = 2
if self.force == 1:
self.node[1] = App.Vector(self.node[0].x,
self.node[1].y,
self.node[0].z)
elif self.force == 2:
self.node[1] = App.Vector(self.node[1].x,
self.node[0].y,
self.node[0].z)
else:
self.force = None
if self.point2 and (len(self.node) > 1):
self.node[1] = self.point2
self.point2 = None
# update the dimline
if self.node and not self.arcmode:
self.dimtrack.update(self.node + [self.point] +
[self.cont])
gui_tool_utils.redraw3DView()
elif arg["Type"] == "SoMouseButtonEvent":
if (arg["State"] == "DOWN") and (arg["Button"] == "BUTTON1"):
import DraftGeomUtils
if self.point:
self.ui.redraw()
if (not self.node) and (not self.support):
gui_tool_utils.getSupport(arg)
if (gui_tool_utils.hasMod(arg, gui_tool_utils.MODALT)
or self.selectmode) and (len(self.node) < 3):
# print("snapped: ",self.info)
if self.info:
ob = self.doc.getObject(self.info['Object'])
if 'Edge' in self.info['Component']:
num = int(
self.info['Component'].lstrip('Edge')) - 1
ed = ob.Shape.Edges[num]
v1 = ed.Vertexes[0].Point
v2 = ed.Vertexes[-1].Point
i1 = i2 = None
for i in range(len(ob.Shape.Vertexes)):
if v1 == ob.Shape.Vertexes[i].Point:
i1 = i
if v2 == ob.Shape.Vertexes[i].Point:
i2 = i
if (i1 is not None) and (i2 is not None):
self.indices.append(num)
if not self.edges:
# nothing snapped yet, we treat it
# as a normal edge-snapped dimension
self.node = [v1, v2]
self.link = [ob, i1, i2]
self.edges.append(ed)
if DraftGeomUtils.geomType(
ed) == "Circle":
# snapped edge is an arc
self.arcmode = "diameter"
self.link = [ob, num]
else:
# there is already a snapped edge,
# so we start angular dimension
self.edges.append(ed)
# self.node now has the 4 endpoints
self.node.extend([v1, v2])
c = DraftGeomUtils.findIntersection(
self.node[0], self.node[1],
self.node[2], self.node[3], True,
True)
if c:
# print("centers:",c)
self.center = c[0]
self.arctrack.setCenter(
self.center)
self.arctrack.on()
for e in self.edges:
for v in e.Vertexes:
self.pts.append(
self.arctrack.getAngle(
v.Point))
self.link = [self.link[0], ob]
else:
_msg(
translate(
"draft",
"Edges don't intersect!"))
self.finish()
return
self.dimtrack.on()
else:
self.node.append(self.point)
self.selectmode = False
# print("node", self.node)
self.dimtrack.update(self.node)
if len(self.node) == 2:
self.point2 = self.node[1]
if len(self.node) == 1:
self.dimtrack.on()
if self.planetrack:
self.planetrack.set(self.node[0])
elif len(self.node) == 2 and self.cont:
self.node.append(self.cont)
self.createObject()
if not self.cont:
self.finish()
elif len(self.node) == 3:
# for unlinked arc mode:
# if self.arcmode:
# v = self.node[1].sub(self.node[0])
# v.multiply(0.5)
# cen = self.node[0].add(v)
# self.node = [self.node[0], self.node[1], cen]
self.createObject()
if not self.cont:
self.finish()
elif self.angledata:
self.node.append(self.point)
self.createObject()
self.finish()
def action(self, arg):
"""Handle the 3D scene events.
This is installed as an EventCallback in the Inventor view.
Parameters
----------
arg: dict
Dictionary with strings that indicates the type of event received
from the 3D view.
"""
if arg["Type"] == "SoKeyboardEvent":
if arg["Key"] == "ESCAPE":
self.finish()
elif arg["Type"] == "SoLocation2Event": # mouse movement detection
(self.point, ctrlPoint, info) = gui_tool_utils.getPoint(self, arg)
if len(self.node) > 0:
last = self.node[-1]
if self.ghost:
if self.point != last:
# TODO: the following doesn't work at the moment
mu = self.point.sub(last).normalize()
# This part used to test for the GUI to obtain
# the camera view but this is unnecessary
# as this command is always launched in the GUI.
_view = Gui.ActiveDocument.ActiveView
mv = _view.getViewDirection().negative()
mw = mv.cross(mu)
_plane = WorkingPlane.plane(u=mu, v=mv, w=mw, pos=last)
tm = _plane.getPlacement().toMatrix()
m = self.ghost.getMatrix()
m = m.multiply(tm.inverse())
m.scale(App.Vector(1, 1, -1))
m = m.multiply(tm)
m.scale(App.Vector(-1, 1, 1))
self.ghost.setMatrix(m)
if self.extendedCopy:
if not gui_tool_utils.hasMod(arg, gui_tool_utils.MODALT):
self.finish()
gui_tool_utils.redraw3DView()
elif arg["Type"] == "SoMouseButtonEvent":
if (arg["State"] == "DOWN") and (arg["Button"] == "BUTTON1"):
if self.point:
self.ui.redraw()
if (self.node == []):
self.node.append(self.point)
self.ui.isRelative.show()
if self.ghost:
self.ghost.on()
_msg(
translate("draft",
"Pick end point of mirror line"))
if self.planetrack:
self.planetrack.set(self.point)
else:
last = self.node[0]
if (self.ui.isCopy.isChecked()
or gui_tool_utils.hasMod(
arg, gui_tool_utils.MODALT)):
self.mirror(last, self.point, True)
else:
self.mirror(last, self.point)
if gui_tool_utils.hasMod(arg, gui_tool_utils.MODALT):
self.extendedCopy = True
else:
self.finish(cont=True)
