701 lines
29 KiB
Python
701 lines
29 KiB
Python
# SPDX-License-Identifier: LGPL-2.1-or-later
|
|
|
|
# ***************************************************************************
|
|
# * (c) 2009, 2010 Yorik van Havre <yorik@uncreated.net> *
|
|
# * (c) 2009, 2010 Ken Cline <cline@frii.com> *
|
|
# * (c) 2020 Eliud Cabrera Castillo <e.cabrera-castillo@tum.de> *
|
|
# * *
|
|
# * This file is part of the FreeCAD CAx development system. *
|
|
# * *
|
|
# * This program is free software; you can redistribute it and/or modify *
|
|
# * it under the terms of the GNU Lesser General Public License (LGPL) *
|
|
# * as published by the Free Software Foundation; either version 2 of *
|
|
# * the License, or (at your option) any later version. *
|
|
# * for detail see the LICENCE text file. *
|
|
# * *
|
|
# * FreeCAD 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 Library General Public License for more details. *
|
|
# * *
|
|
# * You should have received a copy of the GNU Library General Public *
|
|
# * License along with FreeCAD; if not, write to the Free Software *
|
|
# * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 *
|
|
# * USA *
|
|
# * *
|
|
# ***************************************************************************
|
|
"""Provides GUI tools to create circular arc objects."""
|
|
## @package gui_arcs
|
|
# \ingroup draftguitools
|
|
# \brief Provides GUI tools to create circular arc objects.
|
|
|
|
## \addtogroup draftguitools
|
|
# @{
|
|
import math
|
|
from PySide.QtCore import QT_TRANSLATE_NOOP
|
|
|
|
import FreeCAD as App
|
|
import FreeCADGui as Gui
|
|
import Draft
|
|
import DraftVecUtils
|
|
from FreeCAD import Units as U
|
|
from draftguitools import gui_base
|
|
from draftguitools import gui_base_original
|
|
from draftguitools import gui_tool_utils
|
|
from draftguitools import gui_trackers as trackers
|
|
from draftutils import gui_utils
|
|
from draftutils import params
|
|
from draftutils import utils
|
|
from draftutils.messages import _err, _toolmsg
|
|
from draftutils.translate import translate
|
|
|
|
|
|
class Arc(gui_base_original.Creator):
|
|
"""Gui command for the Circular Arc tool."""
|
|
|
|
def __init__(self):
|
|
super().__init__()
|
|
self.closedCircle = False
|
|
self.featureName = "Arc"
|
|
|
|
def GetResources(self):
|
|
"""Set icon, menu and tooltip."""
|
|
return {
|
|
"Pixmap": "Draft_Arc",
|
|
"Accel": "A, R",
|
|
"MenuText": QT_TRANSLATE_NOOP("Draft_Arc", "Arc"),
|
|
"ToolTip": QT_TRANSLATE_NOOP(
|
|
"Draft_Arc", "Creates a circular arc from a center point and a radius"
|
|
),
|
|
}
|
|
|
|
def Activated(self):
|
|
"""Execute when the command is called."""
|
|
super().Activated(name=self.featureName)
|
|
if self.ui:
|
|
self.step = 0
|
|
self.center = None
|
|
self.rad = None
|
|
self.angle = 0 # angle inscribed by arc
|
|
self.tangents = []
|
|
self.tanpoints = []
|
|
if self.featureName == "Arc":
|
|
self.ui.arcUi()
|
|
else:
|
|
self.ui.circleUi()
|
|
self.altdown = False
|
|
self.ui.sourceCmd = self
|
|
self.linetrack = trackers.lineTracker(dotted=True)
|
|
self.arctrack = trackers.arcTracker()
|
|
self.call = self.view.addEventCallback("SoEvent", self.action)
|
|
_toolmsg(translate("draft", "Pick center point"))
|
|
|
|
def finish(self, cont=False):
|
|
"""Terminate the operation.
|
|
|
|
Parameters
|
|
----------
|
|
cont: bool or None, optional
|
|
Restart (continue) the command if `True`, or if `None` and
|
|
`ui.continueMode` is `True`.
|
|
"""
|
|
self.end_callbacks(self.call)
|
|
if self.ui:
|
|
self.linetrack.finalize()
|
|
self.arctrack.finalize()
|
|
super().finish()
|
|
if cont or (cont is None and self.ui and self.ui.continueMode):
|
|
self.Activated()
|
|
|
|
def updateAngle(self, angle):
|
|
"""Update the angle with the new value."""
|
|
# previous absolute angle
|
|
lastangle = self.firstangle + self.angle
|
|
if lastangle <= -2 * math.pi:
|
|
lastangle += 2 * math.pi
|
|
if lastangle >= 2 * math.pi:
|
|
lastangle -= 2 * math.pi
|
|
# compute delta = change in angle:
|
|
d0 = angle - lastangle
|
|
d1 = d0 + 2 * math.pi
|
|
d2 = d0 - 2 * math.pi
|
|
if abs(d0) < min(abs(d1), abs(d2)):
|
|
delta = d0
|
|
elif abs(d1) < abs(d2):
|
|
delta = d1
|
|
else:
|
|
delta = d2
|
|
newangle = self.angle + delta
|
|
# normalize angle, preserving direction
|
|
if newangle >= 2 * math.pi:
|
|
newangle -= 2 * math.pi
|
|
if newangle <= -2 * math.pi:
|
|
newangle += 2 * math.pi
|
|
self.angle = newangle
|
|
|
|
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 not self.ui.mouse:
|
|
pass
|
|
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), self.wp.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.get_mod_alt_key()):
|
|
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.get_mod_alt_key()):
|
|
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(
|
|
self.wp.u, self.point.sub(self.center), self.wp.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(
|
|
self.wp.u, self.point.sub(self.center), self.wp.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.get_mod_alt_key()):
|
|
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()
|
|
_toolmsg(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()
|
|
_toolmsg(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
|
|
_toolmsg(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"))
|
|
ang_offset = DraftVecUtils.angle(
|
|
self.wp.u, self.arctrack.getDeviation(), self.wp.axis
|
|
)
|
|
self.arctrack.setStartAngle(self.firstangle - ang_offset)
|
|
self.step = 3
|
|
_toolmsg(translate("draft", "Pick aperture"))
|
|
else: # choose second angle
|
|
self.step = 4
|
|
self.drawArc()
|
|
self.update_hints()
|
|
|
|
def drawArc(self):
|
|
"""Actually draw the arc object."""
|
|
rot, sup, pts, fil = self.getStrings()
|
|
if self.closedCircle:
|
|
try:
|
|
# The command to run is built as a series of text strings
|
|
# to be committed through the `draftutils.todo.ToDo` class.
|
|
Gui.addModule("Draft")
|
|
if params.get_param("UsePartPrimitives"):
|
|
# Insert a Part::Primitive object
|
|
_base = DraftVecUtils.toString(self.center)
|
|
_cmd = "FreeCAD.ActiveDocument."
|
|
_cmd += 'addObject("Part::Circle", "Circle")'
|
|
_cmd_list = [
|
|
"circle = " + _cmd,
|
|
"circle.Radius = " + str(self.rad),
|
|
"pl = FreeCAD.Placement()",
|
|
"pl.Rotation.Q = " + rot,
|
|
"pl.Base = " + _base,
|
|
"circle.Placement = pl",
|
|
"Draft.autogroup(circle)",
|
|
"Draft.select(circle)",
|
|
"FreeCAD.ActiveDocument.recompute()",
|
|
]
|
|
self.commit(translate("draft", "Create Circle (Part)"), _cmd_list)
|
|
else:
|
|
# Insert a Draft circle
|
|
_base = DraftVecUtils.toString(self.center)
|
|
_cmd = "Draft.make_circle"
|
|
_cmd += "("
|
|
_cmd += "radius=" + str(self.rad) + ", "
|
|
_cmd += "placement=pl, "
|
|
_cmd += "face=" + fil + ", "
|
|
_cmd += "support=" + sup
|
|
_cmd += ")"
|
|
_cmd_list = [
|
|
"pl=FreeCAD.Placement()",
|
|
"pl.Rotation.Q=" + rot,
|
|
"pl.Base=" + _base,
|
|
"circle = " + _cmd,
|
|
"Draft.autogroup(circle)",
|
|
"FreeCAD.ActiveDocument.recompute()",
|
|
]
|
|
self.commit(translate("draft", "Create Circle"), _cmd_list)
|
|
except Exception:
|
|
_err("Draft: error delaying commit")
|
|
else:
|
|
# Not a closed circle, therefore a circular arc
|
|
sta = math.degrees(self.firstangle)
|
|
end = math.degrees(self.firstangle + self.angle)
|
|
if end < sta:
|
|
sta, end = end, sta
|
|
sta %= 360
|
|
end %= 360
|
|
|
|
try:
|
|
Gui.addModule("Draft")
|
|
if params.get_param("UsePartPrimitives"):
|
|
# Insert a Part::Primitive object
|
|
_base = DraftVecUtils.toString(self.center)
|
|
_cmd = "FreeCAD.ActiveDocument."
|
|
_cmd += 'addObject("Part::Circle", "Circle")'
|
|
_cmd_list = [
|
|
"circle = " + _cmd,
|
|
"circle.Radius = " + str(self.rad),
|
|
"circle.Angle1 = " + str(sta),
|
|
"circle.Angle2 = " + str(end),
|
|
"pl = FreeCAD.Placement()",
|
|
"pl.Rotation.Q = " + rot,
|
|
"pl.Base = " + _base,
|
|
"circle.Placement = pl",
|
|
"Draft.autogroup(circle)",
|
|
"Draft.select(circle)",
|
|
"FreeCAD.ActiveDocument.recompute()",
|
|
]
|
|
self.commit(translate("draft", "Create Arc (Part)"), _cmd_list)
|
|
else:
|
|
# Insert a Draft circle
|
|
_base = DraftVecUtils.toString(self.center)
|
|
_cmd = "Draft.make_circle"
|
|
_cmd += "("
|
|
_cmd += "radius=" + str(self.rad) + ", "
|
|
_cmd += "placement=pl, "
|
|
_cmd += "face=" + fil + ", "
|
|
_cmd += "startangle=" + str(sta) + ", "
|
|
_cmd += "endangle=" + str(end) + ", "
|
|
_cmd += "support=" + sup
|
|
_cmd += ")"
|
|
_cmd_list = [
|
|
"pl = FreeCAD.Placement()",
|
|
"pl.Rotation.Q = " + rot,
|
|
"pl.Base = " + _base,
|
|
"circle = " + _cmd,
|
|
"Draft.autogroup(circle)",
|
|
"FreeCAD.ActiveDocument.recompute()",
|
|
]
|
|
self.commit(translate("draft", "Create Arc"), _cmd_list)
|
|
except Exception:
|
|
_err("Draft: error delaying commit")
|
|
|
|
# Finalize full circle or circular arc
|
|
self.finish(cont=None)
|
|
|
|
def numericInput(self, numx, numy, numz):
|
|
"""Validate the entry fields in the user interface.
|
|
|
|
This function is called by the toolbar or taskpanel interface
|
|
when valid x, y, and z have been entered in the input fields.
|
|
"""
|
|
self.center = App.Vector(numx, numy, numz)
|
|
self.node = [self.center]
|
|
self.arctrack.setCenter(self.center)
|
|
self.arctrack.on()
|
|
self.ui.radiusUi()
|
|
self.step = 1
|
|
self.ui.setNextFocus()
|
|
_toolmsg(translate("draft", "Pick radius"))
|
|
self.update_hints()
|
|
|
|
def numericRadius(self, rad):
|
|
"""Validate the entry radius in the user interface.
|
|
|
|
This function is called by the toolbar or taskpanel interface
|
|
when a valid radius has been entered in the input field.
|
|
"""
|
|
import DraftGeomUtils
|
|
|
|
if self.step == 1:
|
|
self.rad = rad
|
|
if len(self.tangents) == 2:
|
|
cir = DraftGeomUtils.circleFrom2tan1rad(self.tangents[0], self.tangents[1], rad)
|
|
if self.center:
|
|
_c = DraftGeomUtils.findClosestCircle(self.center, cir)
|
|
self.center = _c.Center
|
|
else:
|
|
self.center = cir[-1].Center
|
|
elif self.tangents and self.tanpoints:
|
|
cir = DraftGeomUtils.circleFrom1tan1pt1rad(self.tangents[0], self.tanpoints[0], rad)
|
|
if self.center:
|
|
_c = DraftGeomUtils.findClosestCircle(self.center, cir)
|
|
self.center = _c.Center
|
|
else:
|
|
self.center = cir[-1].Center
|
|
if self.closedCircle:
|
|
self.drawArc()
|
|
else:
|
|
self.step = 2
|
|
self.arctrack.setCenter(self.center)
|
|
self.ui.labelRadius.setText(translate("draft", "Start angle"))
|
|
self.ui.radiusValue.setToolTip(translate("draft", "Start angle"))
|
|
self.linetrack.p1(self.center)
|
|
self.linetrack.on()
|
|
self.ui.radiusValue.setText("")
|
|
self.ui.radiusValue.setFocus()
|
|
_toolmsg(translate("draft", "Pick start angle"))
|
|
elif self.step == 2:
|
|
self.ui.labelRadius.setText(translate("draft", "Aperture angle"))
|
|
self.ui.radiusValue.setToolTip(translate("draft", "Aperture angle"))
|
|
self.firstangle = math.radians(rad)
|
|
ang_offset = DraftVecUtils.angle(self.wp.u, self.arctrack.getDeviation(), self.wp.axis)
|
|
self.arctrack.setStartAngle(self.firstangle - ang_offset)
|
|
self.step = 3
|
|
self.ui.radiusValue.setText("")
|
|
self.ui.radiusValue.setFocus()
|
|
_toolmsg(translate("draft", "Pick aperture angle"))
|
|
else:
|
|
self.updateAngle(rad)
|
|
self.angle = math.radians(rad)
|
|
self.step = 4
|
|
self.drawArc()
|
|
self.update_hints()
|
|
|
|
def get_hints(self):
|
|
if self.step == 0:
|
|
hints = [Gui.InputHint(translate("draft", "%1 pick center"), Gui.UserInput.MouseLeft)]
|
|
elif self.step == 1:
|
|
hints = [Gui.InputHint(translate("draft", "%1 pick radius"), Gui.UserInput.MouseLeft)]
|
|
elif self.step == 2:
|
|
hints = [
|
|
Gui.InputHint(translate("draft", "%1 pick start angle"), Gui.UserInput.MouseLeft)
|
|
]
|
|
else:
|
|
hints = [Gui.InputHint(translate("draft", "%1 pick aperture"), Gui.UserInput.MouseLeft)]
|
|
return (
|
|
hints
|
|
+ gui_tool_utils._get_hint_xyz_constrain()
|
|
+ gui_tool_utils._get_hint_mod_constrain()
|
|
+ gui_tool_utils._get_hint_mod_snap()
|
|
)
|
|
|
|
|
|
Gui.addCommand("Draft_Arc", Arc())
|
|
|
|
|
|
class Arc_3Points(gui_base.GuiCommandBase):
|
|
"""GuiCommand for the Draft_Arc_3Points tool."""
|
|
|
|
def __init__(self):
|
|
super().__init__(name="Arc_3Points")
|
|
|
|
def GetResources(self):
|
|
"""Set icon, menu and tooltip."""
|
|
return {
|
|
"Pixmap": "Draft_Arc_3Points",
|
|
"Accel": "A, T",
|
|
"MenuText": QT_TRANSLATE_NOOP("Draft_Arc_3Points", "Arc From 3 Points"),
|
|
"ToolTip": QT_TRANSLATE_NOOP(
|
|
"Draft_Arc_3Points", "Creates a circular arc from 3 points"
|
|
),
|
|
}
|
|
|
|
def Activated(self):
|
|
"""Execute when the command is called."""
|
|
super().Activated()
|
|
|
|
# Reset the values
|
|
self.points = []
|
|
self.normal = None
|
|
self.tracker = trackers.arcTracker()
|
|
self.tracker.autoinvert = False
|
|
|
|
# Set up the working plane and launch the Snapper
|
|
# with the indicated callbacks: one for when the user clicks
|
|
# on the 3D view, and another for when the user moves the pointer.
|
|
import WorkingPlane
|
|
|
|
WorkingPlane.get_working_plane()
|
|
|
|
Gui.Snapper.getPoint(callback=self.getPoint, movecallback=self.drawArc)
|
|
Gui.Snapper.ui.sourceCmd = self
|
|
Gui.Snapper.ui.setTitle(
|
|
title=translate("draft", "Arc From 3 Points"), icon="Draft_Arc_3Points"
|
|
)
|
|
Gui.Snapper.ui.continueCmd.show()
|
|
self.update_hints()
|
|
|
|
def getPoint(self, point, info):
|
|
"""Get the point by clicking on the 3D view.
|
|
|
|
Every time the user clicks on the 3D view this method is run.
|
|
In this case, a point is appended to the list of points,
|
|
and the tracker is updated.
|
|
The object is finally created when three points are picked.
|
|
|
|
Parameters
|
|
----------
|
|
point: Base::Vector
|
|
The point selected in the 3D view.
|
|
|
|
info: str
|
|
Some information obtained about the point passed by the Snapper.
|
|
"""
|
|
# If there is not point, the command was cancelled
|
|
# so the command exits.
|
|
if not point:
|
|
return None
|
|
|
|
# Avoid adding the same point twice
|
|
if point not in self.points:
|
|
self.points.append(point)
|
|
if self.planetrack and len(self.points) == 1:
|
|
self.planetrack.set(point)
|
|
|
|
if len(self.points) < 3:
|
|
# If one or two points were picked, set up again the Snapper
|
|
# to get further points, but update the `last` property
|
|
# with the last selected point.
|
|
#
|
|
# When two points are selected then we can turn on
|
|
# the arc tracker to show the preview of the final curve.
|
|
if len(self.points) == 2:
|
|
self.tracker.on()
|
|
Gui.Snapper.getPoint(
|
|
last=self.points[-1], callback=self.getPoint, movecallback=self.drawArc
|
|
)
|
|
Gui.Snapper.ui.sourceCmd = self
|
|
Gui.Snapper.ui.setTitle(
|
|
title=translate("draft", "Arc From 3 Points"), icon="Draft_Arc_3Points"
|
|
)
|
|
Gui.Snapper.ui.continueCmd.show()
|
|
self.update_hints()
|
|
|
|
else:
|
|
# If three points were already picked in the 3D view
|
|
# proceed with creating the final object.
|
|
# Draw a simple `Part::Feature` if the parameter is `True`.
|
|
Gui.addModule("Draft")
|
|
Gui.addModule("WorkingPlane")
|
|
_cmd = "Draft.make_arc_3points(["
|
|
_cmd += "FreeCAD." + str(self.points[0])
|
|
_cmd += ", FreeCAD." + str(self.points[1])
|
|
_cmd += ", FreeCAD." + str(self.points[2])
|
|
_cmd += "]"
|
|
_cmd += ", placement=pl"
|
|
_cmd += ", primitive=" + str(params.get_param("UsePartPrimitives"))
|
|
_cmd += ")"
|
|
_cmd_list = [
|
|
"pl = WorkingPlane.get_working_plane().get_placement()",
|
|
"circle = " + _cmd,
|
|
"Draft.autogroup(circle)",
|
|
]
|
|
if params.get_param("UsePartPrimitives"):
|
|
_cmd_list.append("Draft.select(circle)")
|
|
_cmd_list.append("FreeCAD.ActiveDocument.recompute()")
|
|
self.commit(translate("draft", "Create Arc From 3 Points"), _cmd_list)
|
|
self.finish(cont=None)
|
|
|
|
def drawArc(self, point, info):
|
|
"""Draw preview arc when we move the pointer in the 3D view.
|
|
|
|
It uses the `gui_trackers.arcTracker.setBy3Points` method.
|
|
|
|
Parameters
|
|
----------
|
|
point: Base::Vector
|
|
The dynamic point passed by the callback
|
|
as we move the pointer in the 3D view.
|
|
|
|
info: str
|
|
Some information obtained from the point by the Snapper.
|
|
"""
|
|
if len(self.points) == 2:
|
|
if point.sub(self.points[1]).Length > 0.001:
|
|
self.tracker.setBy3Points(self.points[0], self.points[1], point)
|
|
|
|
def finish(self, cont=False):
|
|
"""Terminate the operation.
|
|
|
|
Parameters
|
|
----------
|
|
cont: bool or None, optional
|
|
Restart (continue) the command if `True`, or if `None` and
|
|
`ui.continueMode` is `True`.
|
|
"""
|
|
self.tracker.finalize()
|
|
super().finish()
|
|
if cont or (cont is None and Gui.Snapper.ui and Gui.Snapper.ui.continueMode):
|
|
self.Activated()
|
|
|
|
def get_hints(self):
|
|
if len(self.points) == 0:
|
|
hints = [
|
|
Gui.InputHint(translate("draft", "%1 pick first point"), Gui.UserInput.MouseLeft)
|
|
]
|
|
elif len(self.points) == 1:
|
|
hints = [
|
|
Gui.InputHint(translate("draft", "%1 pick second point"), Gui.UserInput.MouseLeft)
|
|
]
|
|
else:
|
|
hints = [
|
|
Gui.InputHint(translate("draft", "%1 pick third point"), Gui.UserInput.MouseLeft)
|
|
]
|
|
return (
|
|
hints
|
|
+ gui_tool_utils._get_hint_xyz_constrain()
|
|
+ gui_tool_utils._get_hint_mod_constrain()
|
|
+ gui_tool_utils._get_hint_mod_snap()
|
|
)
|
|
|
|
|
|
Draft_Arc_3Points = Arc_3Points
|
|
Gui.addCommand("Draft_Arc_3Points", Arc_3Points())
|
|
|
|
|
|
class ArcGroup:
|
|
"""Gui Command group for the Arc tools."""
|
|
|
|
def GetResources(self):
|
|
"""Set icon, menu and tooltip."""
|
|
return {
|
|
"MenuText": QT_TRANSLATE_NOOP("Draft_ArcTools", "Arc Tools"),
|
|
"ToolTip": QT_TRANSLATE_NOOP(
|
|
"Draft_ArcTools", "Tools to create various types of circular arcs"
|
|
),
|
|
}
|
|
|
|
def GetCommands(self):
|
|
"""Return a tuple of commands in the group."""
|
|
return ("Draft_Arc", "Draft_Arc_3Points")
|
|
|
|
def IsActive(self):
|
|
"""Return True when this command should be available."""
|
|
return bool(gui_utils.get_3d_view())
|
|
|
|
|
|
Gui.addCommand("Draft_ArcTools", ArcGroup())
|
|
|
|
## @}
|