def setupUi(self, Dialog):
self.view = FreeCADGui.ActiveDocument.ActiveView
self.stack = []
self.callback = self.view.addEventCallbackPivy(pvy.SoMouseButtonEvent.getClassTypeId(),self.getpoint)
self.callmouse=self.view.addEventCallbackPivy(pvy.SoLocation2Event.getClassTypeId(),self.getmousepoint)
self.distance=0
self.dialog=Dialog
Dialog.setObjectName(_fromUtf8("Dialog"))
Dialog.setWindowFlags(QtCore.Qt.WindowStaysOnTopHint)
Dialog.resize(sizeX, sizeY)
self.buttonBox = QtGui.QDialogButtonBox(Dialog)
self.buttonBox.setGeometry(QtCore.QRect(50, 70, 191, 32))
self.buttonBox.setOrientation(QtCore.Qt.Horizontal)
self.buttonBox.setStandardButtons(QtGui.QDialogButtonBox.Cancel|QtGui.QDialogButtonBox.Ok)
self.buttonBox.setObjectName(_fromUtf8("buttonBox"))
self.buttonBox.button(QtGui.QDialogButtonBox.Ok).setEnabled(False)
self.label = QtGui.QLabel(Dialog)
self.label.setGeometry(QtCore.QRect(30, 10, 66, 17))
self.label.setObjectName(_fromUtf8("label"))
self.lineEdit = QtGui.QLineEdit(Dialog)
self.lineEdit.setGeometry(QtCore.QRect(100, 10, 113, 29))
self.lineEdit.setObjectName(_fromUtf8("lineEdit"))
self.label1 = QtGui.QLabel(Dialog)
self.label1.setGeometry(QtCore.QRect(20, 45, 260, 17))
self.label1.setObjectName(_fromUtf8("label1"))
self.retranslateUi(Dialog)
QtCore.QObject.connect(self.buttonBox, QtCore.SIGNAL(_fromUtf8("accepted()")), self.accept)
QtCore.QObject.connect(self.buttonBox, QtCore.SIGNAL(_fromUtf8("rejected()")), self.reject)
QtCore.QMetaObject.connectSlotsByName(Dialog)
self.tracker = DraftTrackers.lineTracker(scolor=(1,0,0))
self.tracker.raiseTracker()
self.tracker.on()
self.dialog.show()
def setTrackers(self):
v = Draft.get3DView()
if v in self.trackers[0]:
i = self.trackers[0].index(v)
self.grid = self.trackers[1][i]
self.tracker = self.trackers[2][i]
self.extLine = self.trackers[3][i]
self.radiusTracker = self.trackers[4][i]
self.dim1 = self.trackers[5][i]
self.dim2 = self.trackers[6][i]
else:
if Draft.getParam("grid"):
self.grid = DraftTrackers.gridTracker()
else:
self.grid = None
self.tracker = DraftTrackers.snapTracker()
self.extLine = DraftTrackers.lineTracker(dotted=True)
self.radiusTracker = DraftTrackers.radiusTracker()
self.dim1 = DraftTrackers.archDimTracker(mode=2)
self.dim2 = DraftTrackers.archDimTracker(mode=3)
self.trackers[0].append(v)
self.trackers[1].append(self.grid)
self.trackers[2].append(self.tracker)
self.trackers[3].append(self.extLine)
self.trackers[4].append(self.radiusTracker)
self.trackers[5].append(self.dim1)
self.trackers[6].append(self.dim2)
if self.grid and (not self.forceGridOff):
self.grid.set()
def getPoint(self,last=None,callback=None,movecallback=None,extradlg=None):
"""
getPoint([last],[callback],[movecallback],[extradlg]) : gets a 3D point
from the screen. You can provide an existing point, in that case additional
snap options and a tracker are available.
You can also pass a function as callback, which will get called
with the resulting point as argument, when a point is clicked, and optionally
another callback which gets called when the mouse is moved.
If the operation gets cancelled (the user pressed Escape), no point is returned.
Example:
def cb(point):
if point:
print "got a 3D point: ",point
FreeCADGui.Snapper.getPoint(callback=cb)
If the callback function accepts more than one argument, it will also receive
the last snapped object. Finally, a pyqt dialog can be passed as extra taskbox.
"""
import inspect
self.pt = None
self.lastSnappedObject = None
self.ui = FreeCADGui.draftToolBar
self.view = Draft.get3DView()
# setting a track line if we got an existing point
if last:
if not self.trackLine:
self.trackLine = DraftTrackers.lineTracker()
self.trackLine.p1(last)
self.trackLine.on()
def move(event_cb):
event = event_cb.getEvent()
mousepos = event.getPosition()
ctrl = event.wasCtrlDown()
shift = event.wasShiftDown()
self.pt = FreeCADGui.Snapper.snap(mousepos,lastpoint=last,active=ctrl,constrain=shift)
if hasattr(FreeCAD,"DraftWorkingPlane"):
self.ui.displayPoint(self.pt,last,plane=FreeCAD.DraftWorkingPlane,mask=FreeCADGui.Snapper.affinity)
if self.trackLine:
self.trackLine.p2(self.pt)
if movecallback:
movecallback(self.pt)
def getcoords(point,relative=False):
self.pt = point
if relative and last and hasattr(FreeCAD,"DraftWorkingPlane"):
v = FreeCAD.DraftWorkingPlane.getGlobalCoords(point)
self.pt = last.add(v)
accept()
def click(event_cb):
event = event_cb.getEvent()
if event.getButton() == 1:
if event.getState() == coin.SoMouseButtonEvent.DOWN:
accept()
def accept():
self.view.removeEventCallbackPivy(coin.SoMouseButtonEvent.getClassTypeId(),self.callbackClick)
self.view.removeEventCallbackPivy(coin.SoLocation2Event.getClassTypeId(),self.callbackMove)
obj = FreeCADGui.Snapper.lastSnappedObject
FreeCADGui.Snapper.off()
self.ui.offUi()
if self.trackLine:
self.trackLine.off()
if callback:
if len(inspect.getargspec(callback).args) > 2:
callback(self.pt,obj)
else:
callback(self.pt)
self.pt = None
def cancel():
self.view.removeEventCallbackPivy(coin.SoMouseButtonEvent.getClassTypeId(),self.callbackClick)
self.view.removeEventCallbackPivy(coin.SoLocation2Event.getClassTypeId(),self.callbackMove)
FreeCADGui.Snapper.off()
self.ui.offUi()
if self.trackLine:
self.trackLine.off()
if callback:
callback(None)
# adding callback functions
self.ui.pointUi(cancel=cancel,getcoords=getcoords,extra=extradlg,rel=bool(last))
self.callbackClick = self.view.addEventCallbackPivy(coin.SoMouseButtonEvent.getClassTypeId(),click)
self.callbackMove = self.view.addEventCallbackPivy(coin.SoLocation2Event.getClassTypeId(),move)
def setArchDims(self,p1,p2):
"show arch dimensions between 2 points"
if not self.dim1:
self.dim1 = DraftTrackers.archDimTracker(mode=2)
if not self.dim2:
self.dim1 = DraftTrackers.archDimTracker(mode=3)
self.dim1.p1(p1)
self.dim2.p1(p1)
self.dim1.p2(p2)
self.dim2.p2(p2)
if self.dim1.Distance:
self.dim1.on()
if self.dim2.Distance:
self.dim2.on()
def setArchDims(self, p1, p2):
"show arch dimensions between 2 points"
if not self.dim1:
self.dim1 = DraftTrackers.archDimTracker(mode=2)
if not self.dim2:
self.dim1 = DraftTrackers.archDimTracker(mode=3)
self.dim1.p1(p1)
self.dim2.p1(p1)
self.dim1.p2(p2)
self.dim2.p2(p2)
if self.dim1.Distance:
self.dim1.on()
if self.dim2.Distance:
self.dim2.on()
def place(self, path):
import FreeCADGui
import Part
self.shape = Part.read(path)
if hasattr(FreeCADGui, "Snapper"):
try:
import DraftTrackers
except Exception:
import draftguitools.gui_trackers as DraftTrackers
self.box = DraftTrackers.ghostTracker(self.shape,
dotted=True,
scolor=(0.0, 0.0, 1.0),
swidth=1.0)
self.delta = self.shape.BoundBox.Center
self.box.move(self.delta)
self.box.on()
if hasattr(FreeCAD, "DraftWorkingPlane"):
FreeCAD.DraftWorkingPlane.setup()
self.origin = self.makeOriginWidget()
FreeCADGui.Snapper.getPoint(movecallback=self.mouseMove,
callback=self.mouseClick,
extradlg=self.origin)
else:
Part.show(self.shape)
def setupUi(self, Dialog):
self.view = FreeCADGui.ActiveDocument.ActiveView
self.stack = []
self.callback = self.view.addEventCallbackPivy(pvy.SoMouseButtonEvent.getClassTypeId(),self.getpoint)
self.callmouse=self.view.addEventCallbackPivy(pvy.SoLocation2Event.getClassTypeId(),self.getmousepoint)
self.distance=0
self.dialog=Dialog
Dialog.setObjectName(_fromUtf8("Dialog"))
Dialog.setWindowFlags(QtCore.Qt.WindowStaysOnTopHint)
Dialog.resize(sizeX, sizeY)
self.buttonBox = QtGui.QDialogButtonBox(Dialog)
self.buttonBox.setGeometry(QtCore.QRect(50, 70, 191, 32))
self.buttonBox.setOrientation(QtCore.Qt.Horizontal)
self.buttonBox.setStandardButtons(QtGui.QDialogButtonBox.Cancel|QtGui.QDialogButtonBox.Ok)
self.buttonBox.setObjectName(_fromUtf8("buttonBox"))
self.buttonBox.button(QtGui.QDialogButtonBox.Ok).setEnabled(False)
self.label = QtGui.QLabel(Dialog)
self.label.setGeometry(QtCore.QRect(30, 10, 86, 17))
self.label.setObjectName(_fromUtf8("label"))
self.lineEdit = QtGui.QLineEdit(Dialog)
self.lineEdit.setGeometry(QtCore.QRect(140, 10, 153, 29))
self.lineEdit.setObjectName(_fromUtf8("lineEdit"))
self.label1 = QtGui.QLabel(Dialog)
self.label1.setGeometry(QtCore.QRect(20, 45, 260, 17))
self.label1.setObjectName(_fromUtf8("label1"))
self.retranslateUi(Dialog)
QtCore.QObject.connect(self.buttonBox, QtCore.SIGNAL(_fromUtf8("accepted()")), self.accept)
QtCore.QObject.connect(self.buttonBox, QtCore.SIGNAL(_fromUtf8("rejected()")), self.reject)
QtCore.QMetaObject.connectSlotsByName(Dialog)
self.tracker = DraftTrackers.lineTracker(scolor=(1,0,0))
self.tracker.raiseTracker()
self.tracker.on()
self.dialog.show()
def Activated(self):
global QtGui, QtCore
from PyQt4 import QtGui, QtCore
self.Width = 0.1
self.Height = 1
self.Align = "Center"
self.Length = None
self.continueCmd = False
p = FreeCAD.ParamGet("User parameter:BaseApp/Preferences/Mod/Arch")
self.JOIN_WALLS = p.GetBool("joinWallSketches")
sel = FreeCADGui.Selection.getSelection()
done = False
self.existing = []
if sel:
import Draft
if Draft.getType(sel[0]) != "Wall":
FreeCAD.ActiveDocument.openTransaction(
str(translate("Arch", "Create Wall")))
FreeCADGui.doCommand('import Arch')
for obj in sel:
FreeCADGui.doCommand(
'Arch.makeWall(FreeCAD.ActiveDocument.' + obj.Name +
')')
FreeCAD.ActiveDocument.commitTransaction()
FreeCAD.ActiveDocument.recompute()
done = True
if not done:
import DraftTrackers
self.points = []
self.tracker = DraftTrackers.boxTracker()
FreeCADGui.Snapper.getPoint(callback=self.getPoint,
extradlg=self.taskbox())
def insert(self, index=None):
import Part
if not index:
index = self.form.tree.selectedIndexes()
if not index:
return
index = index[0]
path = self.dirmodel.filePath(index)
self.name = os.path.splitext(os.path.basename(path))[0]
if path.lower().endswith(".stp") or path.lower().endswith(
".step") or path.lower().endswith(
".brp") or path.lower().endswith(".brep"):
self.shape = Part.read(path)
if hasattr(FreeCADGui, "Snapper"):
import DraftTrackers
self.box = DraftTrackers.ghostTracker(self.shape,
dotted=True,
scolor=(0.0, 0.0, 1.0),
swidth=1.0)
self.delta = self.shape.BoundBox.Center
self.box.move(self.delta)
self.box.on()
if hasattr(FreeCAD, "DraftWorkingPlane"):
FreeCAD.DraftWorkingPlane.setup()
self.origin = self.makeOriginWidget()
FreeCADGui.Snapper.getPoint(movecallback=self.move,
callback=self.place,
extradlg=self.origin)
else:
Part.show(self.shape)
elif path.lower().endswith(".fcstd"):
FreeCADGui.ActiveDocument.mergeProject(path)
def Activated(self):
global QtGui, QtCore
from PyQt4 import QtGui, QtCore
self.Width = 0.1
self.Height = 1
self.Align = "Center"
sel = FreeCADGui.Selection.getSelection()
done = False
self.existing = []
if sel:
import Draft
if Draft.getType(sel[0]) != "Wall":
FreeCAD.ActiveDocument.openTransaction("Wall")
for obj in sel:
makeWall(obj)
FreeCAD.ActiveDocument.commitTransaction()
done = True
if not done:
import DraftTrackers
self.points = []
self.tracker = DraftTrackers.boxTracker()
FreeCADGui.Snapper.getPoint(callback=self.getPoint,
extradlg=self.taskbox())
def Activated(self):
global QtGui, QtCore
from PyQt4 import QtGui, QtCore
self.Width = 0.1
self.Height = 1
self.Align = "Center"
self.continueCmd = False
p = FreeCAD.ParamGet("User parameter:BaseApp/Preferences/Mod/Arch")
self.JOIN_WALLS = p.GetBool("joinWallSketches")
sel = FreeCADGui.Selection.getSelection()
done = False
self.existing = []
if sel:
import Draft
if Draft.getType(sel[0]) != "Wall":
FreeCAD.ActiveDocument.openTransaction(str(translate("Arch","Create Wall")))
FreeCADGui.doCommand('import Arch')
for obj in sel:
FreeCADGui.doCommand('Arch.makeWall(FreeCAD.ActiveDocument.'+obj.Name+')')
FreeCAD.ActiveDocument.commitTransaction()
FreeCAD.ActiveDocument.recompute()
done = True
if not done:
import DraftTrackers
self.points = []
self.tracker = DraftTrackers.boxTracker()
FreeCADGui.Snapper.getPoint(callback=self.getPoint,extradlg=self.taskbox())
def Activated(self):
p = FreeCAD.ParamGet("User parameter:BaseApp/Preferences/Mod/Arch")
self.Length = p.GetFloat("PanelLength",1000)
self.Width = p.GetFloat("PanelWidth",1000)
self.Thickness = p.GetFloat("PanelThickness",10)
self.Profile = None
self.continueCmd = False
self.rotated = False
self.DECIMALS = FreeCAD.ParamGet("User parameter:BaseApp/Preferences/Units").GetInt("Decimals",2)
self.FORMAT = "%." + str(self.DECIMALS) + "f mm"
sel = FreeCADGui.Selection.getSelection()
if sel:
if len(sel) == 1:
if Draft.getType(sel[0]) == "Panel":
return
FreeCAD.ActiveDocument.openTransaction(str(translate("Arch","Create Panel")))
FreeCADGui.addModule("Arch")
for obj in sel:
FreeCADGui.doCommand("Arch.makePanel(FreeCAD.ActiveDocument." + obj.Name + ",thickness=" + str(self.Thickness) + ")")
FreeCAD.ActiveDocument.commitTransaction()
FreeCAD.ActiveDocument.recompute()
return
# interactive mode
if hasattr(FreeCAD,"DraftWorkingPlane"):
FreeCAD.DraftWorkingPlane.setup()
import DraftTrackers
self.points = []
self.tracker = DraftTrackers.boxTracker()
self.tracker.width(self.Width)
self.tracker.height(self.Thickness)
self.tracker.length(self.Length)
self.tracker.on()
FreeCADGui.Snapper.getPoint(callback=self.getPoint,movecallback=self.update,extradlg=self.taskbox())
def Activated(self):
p = FreeCAD.ParamGet("User parameter:BaseApp/Preferences/Mod/Arch")
self.Length = p.GetFloat("PanelLength",1000)
self.Width = p.GetFloat("PanelWidth",1000)
self.Thickness = p.GetFloat("PanelThickness",10)
self.Profile = None
self.continueCmd = False
self.rotated = False
sel = FreeCADGui.Selection.getSelection()
if sel:
if len(sel) == 1:
if Draft.getType(sel[0]) == "Panel":
return
FreeCAD.ActiveDocument.openTransaction(str(translate("Arch","Create Panel")))
FreeCADGui.addModule("Arch")
for obj in sel:
FreeCADGui.doCommand("Arch.makePanel(FreeCAD.ActiveDocument." + obj.Name + ",thickness=" + str(self.Thickness) + ")")
FreeCAD.ActiveDocument.commitTransaction()
FreeCAD.ActiveDocument.recompute()
return
# interactive mode
if hasattr(FreeCAD,"DraftWorkingPlane"):
FreeCAD.DraftWorkingPlane.setup()
import DraftTrackers
self.points = []
self.tracker = DraftTrackers.boxTracker()
self.tracker.width(self.Width)
self.tracker.height(self.Thickness)
self.tracker.length(self.Length)
self.tracker.on()
FreeCADGui.Snapper.getPoint(callback=self.getPoint,movecallback=self.update,extradlg=self.taskbox())
def Activated(self):
global QtGui, QtCore
from PyQt4 import QtGui, QtCore
self.Length = 0.5
self.Width = 0.2
self.Height = 1
self.continueCmd = False
sel = FreeCADGui.Selection.getSelection()
if sel:
# direct creation
FreeCAD.ActiveDocument.openTransaction(str(translate("Arch","Create Structure")))
FreeCADGui.doCommand("import Arch")
# if selection contains structs and axes, make a system
st = Draft.getObjectsOfType(sel,"Structure")
ax = Draft.getObjectsOfType(sel,"Axis")
if st and ax:
FreeCADGui.doCommand("Arch.makeStructuralSystem(" + ArchCommands.getStringList(st) + "," + ArchCommands.getStringList(ax) + ")")
else:
# else, do normal structs
for obj in sel:
FreeCADGui.doCommand("Arch.makeStructure(FreeCAD.ActiveDocument." + obj.Name + ")")
FreeCAD.ActiveDocument.commitTransaction()
FreeCAD.ActiveDocument.recompute()
else:
# interactive mode
import DraftTrackers
self.points = []
self.tracker = DraftTrackers.boxTracker()
self.tracker.width(self.Width)
self.tracker.height(self.Height)
self.tracker.length(self.Length)
self.tracker.on()
FreeCADGui.Snapper.getPoint(callback=self.getPoint,movecallback=self.update,extradlg=self.taskbox())
def Activated(self):
global QtGui, QtCore
from PyQt4 import QtGui, QtCore
self.Width = 0.1
self.Height = 1
self.Align = "Center"
self.continueCmd = False
sel = FreeCADGui.Selection.getSelection()
done = False
self.existing = []
if sel:
import Draft
if Draft.getType(sel[0]) != "Wall":
FreeCAD.ActiveDocument.openTransaction("Wall")
for obj in sel:
makeWall(obj)
FreeCAD.ActiveDocument.commitTransaction()
done = True
if not done:
import DraftTrackers
self.points = []
self.tracker = DraftTrackers.boxTracker()
FreeCADGui.Snapper.getPoint(callback=self.getPoint,extradlg=self.taskbox())
def constrain(self,point,basepoint=None,axis=None):
'''constrain(point,basepoint=None,axis=None: Returns a
constrained point. Axis can be "x","y" or "z" or a custom vector. If None,
the closest working plane axis will be picked.
Basepoint is the base point used to figure out from where the point
must be constrained. If no basepoint is given, the current point is
used as basepoint.'''
# without the Draft module fully loaded, no axes system!"
if not hasattr(FreeCAD,"DraftWorkingPlane"):
return point
point = Vector(point)
# setup trackers if needed
if not self.constrainLine:
self.constrainLine = DraftTrackers.lineTracker(dotted=True)
# setting basepoint
if not basepoint:
if not self.basepoint:
self.basepoint = point
else:
self.basepoint = basepoint
delta = point.sub(self.basepoint)
# setting constraint axis
if not self.affinity:
self.affinity = FreeCAD.DraftWorkingPlane.getClosestAxis(delta)
if isinstance(axis,FreeCAD.Vector):
self.constraintAxis = axis
elif axis == "x":
self.constraintAxis = FreeCAD.DraftWorkingPlane.u
elif axis == "y":
self.constraintAxis = FreeCAD.DraftWorkingPlane.v
elif axis == "z":
self.constraintAxis = FreeCAD.DraftWorkingPlane.axis
else:
if self.affinity == "x":
self.constraintAxis = FreeCAD.DraftWorkingPlane.u
elif self.affinity == "y":
self.constraintAxis = FreeCAD.DraftWorkingPlane.v
else:
self.constraintAxis = FreeCAD.DraftWorkingPlane.axis
# calculating constrained point
cdelta = fcvec.project(delta,self.constraintAxis)
npoint = self.basepoint.add(cdelta)
# setting constrain line
if self.constrainLine:
if point != npoint:
self.constrainLine.p1(point)
self.constrainLine.p2(npoint)
self.constrainLine.on()
else:
self.constrainLine.off()
return npoint
def Activated(self):
self.Align = "Center"
self.Length = None
self.lengthValue = 0
self.continueCmd = False
p = FreeCAD.ParamGet("User parameter:BaseApp/Preferences/Mod/Arch")
self.Width = p.GetFloat("WallWidth", 200)
self.Height = p.GetFloat("WallHeight", 3000)
self.JOIN_WALLS_SKETCHES = p.GetBool("joinWallSketches", False)
self.AUTOJOIN = p.GetBool("autoJoinWalls", True)
self.DECIMALS = FreeCAD.ParamGet(
"User parameter:BaseApp/Preferences/Units").GetInt("Decimals", 2)
import DraftGui
self.FORMAT = DraftGui.makeFormatSpec(self.DECIMALS, 'Length')
sel = FreeCADGui.Selection.getSelectionEx()
done = False
self.existing = []
if sel:
# automatic mode
import Draft
if Draft.getType(sel[0].Object) != "Wall":
FreeCAD.ActiveDocument.openTransaction(
translate("Arch", "Create Wall"))
FreeCADGui.addModule("Arch")
for selobj in sel:
if Draft.getType(selobj.Object) == "Space":
spacedone = False
if selobj.HasSubObjects:
if "Face" in selobj.SubElementNames[0]:
idx = int(selobj.SubElementNames[0][4:])
FreeCADGui.doCommand(
"Arch.makeWall(FreeCAD.ActiveDocument." +
selobj.Object.Name + ",face=" + str(idx) +
")")
spacedone = True
if not spacedone:
FreeCADGui.doCommand(
'Arch.makeWall(FreeCAD.ActiveDocument.' +
selobj.Object.Name + ')')
else:
FreeCADGui.doCommand(
'Arch.makeWall(FreeCAD.ActiveDocument.' +
selobj.Object.Name + ')')
FreeCAD.ActiveDocument.commitTransaction()
FreeCAD.ActiveDocument.recompute()
done = True
if not done:
# interactive mode
import DraftTrackers
self.points = []
self.tracker = DraftTrackers.boxTracker()
if hasattr(FreeCAD, "DraftWorkingPlane"):
FreeCAD.DraftWorkingPlane.setup()
FreeCADGui.Snapper.getPoint(callback=self.getPoint,
extradlg=self.taskbox())
def Activated(self):
self.Align = "Center"
self.Length = None
self.continueCmd = False
p = FreeCAD.ParamGet("User parameter:BaseApp/Preferences/Mod/Arch")
self.Width = p.GetFloat("WallWidth", 200)
self.Height = p.GetFloat("WallHeight", 3000)
self.JOIN_WALLS_SKETCHES = p.GetBool("joinWallSketches", False)
self.AUTOJOIN = p.GetBool("autoJoinWalls", True)
self.DECIMALS = FreeCAD.ParamGet("User parameter:BaseApp/Preferences/Units").GetInt("Decimals", 2)
import DraftGui
self.FORMAT = DraftGui.makeFormatSpec(self.DECIMALS, "Length")
sel = FreeCADGui.Selection.getSelectionEx()
done = False
self.existing = []
if sel:
# automatic mode
import Draft
if Draft.getType(sel[0].Object) != "Wall":
FreeCAD.ActiveDocument.openTransaction(translate("Arch", "Create Wall"))
FreeCADGui.doCommand("import Arch")
for selobj in sel:
if Draft.getType(selobj.Object) == "Space":
spacedone = False
if selobj.HasSubObjects:
if "Face" in selobj.SubElementNames[0]:
idx = int(selobj.SubElementNames[0][4:])
FreeCADGui.doCommand(
"Arch.makeWall(FreeCAD.ActiveDocument."
+ selobj.Object.Name
+ ",face="
+ str(idx)
+ ")"
)
spacedone = True
if not spacedone:
FreeCADGui.doCommand("Arch.makeWall(FreeCAD.ActiveDocument." + selobj.Object.Name + ")")
else:
FreeCADGui.doCommand("Arch.makeWall(FreeCAD.ActiveDocument." + selobj.Object.Name + ")")
FreeCAD.ActiveDocument.commitTransaction()
FreeCAD.ActiveDocument.recompute()
done = True
if not done:
# interactive mode
import DraftTrackers
self.points = []
self.tracker = DraftTrackers.boxTracker()
if hasattr(FreeCAD, "DraftWorkingPlane"):
FreeCAD.DraftWorkingPlane.setup()
FreeCADGui.Snapper.getPoint(callback=self.getPoint, extradlg=self.taskbox())
def Activated(self):
p = FreeCAD.ParamGet("User parameter:BaseApp/Preferences/Mod/Arch")
self.Length = p.GetFloat("StructureLength", 100)
self.Width = p.GetFloat("StructureWidth", 100)
self.Height = p.GetFloat("StructureHeight", 1000)
self.Profile = None
self.continueCmd = False
sel = FreeCADGui.Selection.getSelection()
if sel:
st = Draft.getObjectsOfType(sel, "Structure")
ax = Draft.getObjectsOfType(sel, "Axis")
if ax:
FreeCAD.ActiveDocument.openTransaction(str(translate("Arch", "Create Structural System")))
FreeCADGui.addModule("Arch")
if st:
FreeCADGui.doCommand(
"Arch.makeStructuralSystem("
+ ArchCommands.getStringList(st)
+ ","
+ ArchCommands.getStringList(ax)
+ ")"
)
else:
FreeCADGui.doCommand("Arch.makeStructuralSystem(axes=" + ArchCommands.getStringList(ax) + ")")
FreeCAD.ActiveDocument.commitTransaction()
FreeCAD.ActiveDocument.recompute()
return
elif not (ax) and not (st):
FreeCAD.ActiveDocument.openTransaction(str(translate("Arch", "Create Structure")))
FreeCADGui.addModule("Arch")
for obj in sel:
FreeCADGui.doCommand("Arch.makeStructure(FreeCAD.ActiveDocument." + obj.Name + ")")
FreeCAD.ActiveDocument.commitTransaction()
FreeCAD.ActiveDocument.recompute()
return
# interactive mode
if hasattr(FreeCAD, "DraftWorkingPlane"):
FreeCAD.DraftWorkingPlane.setup()
import DraftTrackers, ArchPrecast
self.points = []
self.tracker = DraftTrackers.boxTracker()
self.tracker.width(self.Width)
self.tracker.height(self.Height)
self.tracker.length(self.Length)
self.tracker.on()
self.precast = ArchPrecast._PrecastTaskPanel()
self.dents = ArchPrecast._DentsTaskPanel()
self.precast.Dents = self.dents
FreeCADGui.Snapper.getPoint(
callback=self.getPoint,
movecallback=self.update,
extradlg=[self.taskbox(), self.precast.form, self.dents.form],
)
def Activated(self, name=translate("draft", "Fillet")):
DraftTools.Creator.Activated(self, name)
if not self.doc:
FCC.PrintWarning(translate("draft", "No active document") + "\n")
return
if self.ui:
self.rad = 100
self.chamfer = False
self.delete = False
label = translate("draft", "Fillet radius")
tooltip = translate("draft", "Radius of fillet")
# Call the Task panel for a radius
# The graphical widgets are defined in DraftGui
self.ui.taskUi(title=name, icon="Draft_Fillet")
self.ui.radiusUi()
self.ui.sourceCmd = self
self.ui.labelRadius.setText(label)
self.ui.radiusValue.setToolTip(tooltip)
self.ui.setRadiusValue(self.rad, "Length")
self.ui.check_delete = self.ui._checkbox("isdelete",
self.ui.layout,
checked=self.delete)
self.ui.check_delete.setText(
translate("draft", "Delete original objects"))
self.ui.check_delete.show()
self.ui.check_chamfer = self.ui._checkbox("ischamfer",
self.ui.layout,
checked=self.chamfer)
self.ui.check_chamfer.setText(translate("draft", "Create chamfer"))
self.ui.check_chamfer.show()
QtCore.QObject.connect(self.ui.check_delete,
QtCore.SIGNAL("stateChanged(int)"),
self.set_delete)
QtCore.QObject.connect(self.ui.check_chamfer,
QtCore.SIGNAL("stateChanged(int)"),
self.set_chamfer)
self.linetrack = DraftTrackers.lineTracker(dotted=True)
self.arctrack = DraftTrackers.arcTracker()
# self.call = self.view.addEventCallback("SoEvent", self.action)
FCC.PrintMessage(translate("draft", "Enter radius") + "\n")
def Activated(self):
p = FreeCAD.ParamGet("User parameter:BaseApp/Preferences/Mod/Arch")
self.Length = p.GetFloat("StructureLength", 100)
self.Width = p.GetFloat("StructureWidth", 100)
self.Height = p.GetFloat("StructureHeight", 1000)
self.Profile = None
self.continueCmd = False
self.DECIMALS = FreeCAD.ParamGet(
"User parameter:BaseApp/Preferences/Units").GetInt("Decimals", 2)
import DraftGui
self.FORMAT = DraftGui.makeFormatSpec(self.DECIMALS, 'Length')
sel = FreeCADGui.Selection.getSelection()
if sel:
st = Draft.getObjectsOfType(sel, "Structure")
ax = Draft.getObjectsOfType(sel, "Axis")
if ax:
FreeCAD.ActiveDocument.openTransaction(
str(translate("Arch", "Create Structural System")))
FreeCADGui.addModule("Arch")
if st:
FreeCADGui.doCommand("Arch.makeStructuralSystem(" +
ArchCommands.getStringList(st) + "," +
ArchCommands.getStringList(ax) + ")")
else:
FreeCADGui.doCommand("Arch.makeStructuralSystem(axes=" +
ArchCommands.getStringList(ax) + ")")
FreeCAD.ActiveDocument.commitTransaction()
FreeCAD.ActiveDocument.recompute()
return
elif not (ax) and not (st):
FreeCAD.ActiveDocument.openTransaction(
str(translate("Arch", "Create Structure")))
FreeCADGui.addModule("Arch")
for obj in sel:
FreeCADGui.doCommand(
"Arch.makeStructure(FreeCAD.ActiveDocument." +
obj.Name + ")")
FreeCAD.ActiveDocument.commitTransaction()
FreeCAD.ActiveDocument.recompute()
return
# interactive mode
if hasattr(FreeCAD, "DraftWorkingPlane"):
FreeCAD.DraftWorkingPlane.setup()
import DraftTrackers
self.points = []
self.tracker = DraftTrackers.boxTracker()
self.tracker.width(self.Width)
self.tracker.height(self.Height)
self.tracker.length(self.Length)
self.tracker.on()
FreeCADGui.Snapper.getPoint(callback=self.getPoint,
movecallback=self.update,
extradlg=self.taskbox())
def Activated(self):
import DraftTrackers
self.points = []
self.normal = None
self.tracker = DraftTrackers.arcTracker()
self.tracker.autoinvert = False
if hasattr(FreeCAD, "DraftWorkingPlane"):
FreeCAD.DraftWorkingPlane.setup()
FreeCADGui.Snapper.getPoint(callback=self.getPoint,
movecallback=self.drawArc)
def setTrackers(self):
v = Draft.get3DView()
if v in self.trackers[0]:
i = self.trackers[0].index(v)
self.grid = self.trackers[1][i]
self.tracker = self.trackers[2][i]
self.extLine = self.trackers[3][i]
self.radiusTracker = self.trackers[4][i]
self.dim1 = self.trackers[5][i]
self.dim2 = self.trackers[6][i]
else:
if Draft.getParam("grid"):
self.grid = DraftTrackers.gridTracker()
else:
self.grid = None
self.tracker = DraftTrackers.snapTracker()
self.extLine = DraftTrackers.lineTracker(dotted=True)
self.radiusTracker = DraftTrackers.radiusTracker()
self.dim1 = DraftTrackers.archDimTracker(mode=2)
self.dim2 = DraftTrackers.archDimTracker(mode=3)
self.trackers[0].append(v)
self.trackers[1].append(self.grid)
self.trackers[2].append(self.tracker)
self.trackers[3].append(self.extLine)
self.trackers[4].append(self.radiusTracker)
self.trackers[5].append(self.dim1)
self.trackers[6].append(self.dim2)
if self.grid and (not self.forceGridOff):
self.grid.set()
def Activated(self):
p = FreeCAD.ParamGet("User parameter:BaseApp/Preferences/Mod/Arch")
self.Length = p.GetFloat("StructureLength",100)
self.Width = p.GetFloat("StructureWidth",100)
self.Height = p.GetFloat("StructureHeight",1000)
self.Profile = None
self.continueCmd = False
self.bpoint = None
self.bmode = False
sel = FreeCADGui.Selection.getSelection()
if sel:
st = Draft.getObjectsOfType(sel,"Structure")
ax = Draft.getObjectsOfType(sel,"Axis")
if ax:
FreeCAD.ActiveDocument.openTransaction(translate("Arch","Create Structural System"))
FreeCADGui.addModule("Arch")
if st:
FreeCADGui.doCommand("obj = Arch.makeStructuralSystem(" + ArchCommands.getStringList(st) + "," + ArchCommands.getStringList(ax) + ")")
else:
FreeCADGui.doCommand("obj = Arch.makeStructuralSystem(axes=" + ArchCommands.getStringList(ax) + ")")
FreeCADGui.addModule("Draft")
FreeCADGui.doCommand("Draft.autogroup(obj)")
FreeCAD.ActiveDocument.commitTransaction()
FreeCAD.ActiveDocument.recompute()
return
elif not(ax) and not(st):
FreeCAD.ActiveDocument.openTransaction(translate("Arch","Create Structure"))
FreeCADGui.addModule("Arch")
for obj in sel:
FreeCADGui.doCommand("obj = Arch.makeStructure(FreeCAD.ActiveDocument." + obj.Name + ")")
FreeCADGui.addModule("Draft")
FreeCADGui.doCommand("Draft.autogroup(obj)")
FreeCAD.ActiveDocument.commitTransaction()
FreeCAD.ActiveDocument.recompute()
return
# interactive mode
if hasattr(FreeCAD,"DraftWorkingPlane"):
FreeCAD.DraftWorkingPlane.setup()
import DraftTrackers,ArchPrecast
self.points = []
self.tracker = DraftTrackers.boxTracker()
self.tracker.width(self.Width)
self.tracker.height(self.Height)
self.tracker.length(self.Length)
self.tracker.on()
self.precast = ArchPrecast._PrecastTaskPanel()
self.dents = ArchPrecast._DentsTaskPanel()
self.precast.Dents = self.dents
FreeCADGui.Snapper.getPoint(callback=self.getPoint,movecallback=self.update,extradlg=[self.taskbox(),self.precast.form,self.dents.form])
def __init__(self,beam):
self.beam=beam
self.doc=FreeCAD.ActiveDocument
if self.doc == None:
FreeCAD.newDocument("Sans_Nom")
self.view = FreeCADGui.ActiveDocument.ActiveView
self.units=FreeCAD.Units.Quantity(1.0,FreeCAD.Units.Length)
self.points = []
#snapper starting
self.tracker = DraftTrackers.lineTracker()
self.tracker.on()
FreeCADGui.Snapper.getPoint(callback=self.getPoint1)
def Activated(self):
# here we will store our points
self.points = []
# we build a special cube tracker which is a list of 4 rectangle trackers
self.cubetracker = []
self.LengthValue = 0
self.WidthValue = 0
self.HeightValue = 0
self.currentpoint = None
for i in range(4):
self.cubetracker.append(DraftTrackers.rectangleTracker())
if hasattr(FreeCADGui,"Snapper"):
FreeCADGui.Snapper.getPoint(callback=self.PointCallback,movecallback=self.MoveCallback,extradlg=self.taskbox())
def Activated(self):
p = FreeCAD.ParamGet("User parameter:BaseApp/Preferences/Mod/Arch")
self.Align = ["Center","Left","Right"][p.GetInt("WallAlignment",0)]
self.MultiMat = None
self.Length = None
self.lengthValue = 0
self.continueCmd = False
self.Width = p.GetFloat("WallWidth",200)
self.Height = p.GetFloat("WallHeight",3000)
self.JOIN_WALLS_SKETCHES = p.GetBool("joinWallSketches",False)
self.AUTOJOIN = p.GetBool("autoJoinWalls",True)
sel = FreeCADGui.Selection.getSelectionEx()
done = False
self.existing = []
if sel:
# automatic mode
import Draft
if Draft.getType(sel[0].Object) != "Wall":
FreeCAD.ActiveDocument.openTransaction(translate("Arch","Create Wall"))
FreeCADGui.addModule("Arch")
for selobj in sel:
if Draft.getType(selobj.Object) == "Space":
spacedone = False
if selobj.HasSubObjects:
if "Face" in selobj.SubElementNames[0]:
idx = int(selobj.SubElementNames[0][4:])
FreeCADGui.doCommand("obj = Arch.makeWall(FreeCAD.ActiveDocument."+selobj.Object.Name+",face="+str(idx)+")")
spacedone = True
if not spacedone:
FreeCADGui.doCommand('obj = Arch.makeWall(FreeCAD.ActiveDocument.'+selobj.Object.Name+')')
else:
FreeCADGui.doCommand('obj = Arch.makeWall(FreeCAD.ActiveDocument.'+selobj.Object.Name+')')
FreeCADGui.addModule("Draft")
FreeCADGui.doCommand("Draft.autogroup(obj)")
FreeCAD.ActiveDocument.commitTransaction()
FreeCAD.ActiveDocument.recompute()
done = True
if not done:
# interactive mode
import DraftTrackers
self.points = []
self.tracker = DraftTrackers.boxTracker()
if hasattr(FreeCAD,"DraftWorkingPlane"):
FreeCAD.DraftWorkingPlane.setup()
FreeCADGui.Snapper.getPoint(callback=self.getPoint,extradlg=self.taskbox(),title=translate("Arch","First point of wall")+":")
def Activated(self):
global QtGui, QtCore
from PyQt4 import QtGui, QtCore
p = FreeCAD.ParamGet("User parameter:BaseApp/Preferences/Mod/Arch")
self.Length = p.GetFloat("StructureLength", 100)
self.Width = p.GetFloat("StructureWidth", 100)
self.Height = p.GetFloat("StructureHeight", 1000)
self.Profile = 0
self.continueCmd = False
sel = FreeCADGui.Selection.getSelection()
if sel:
if Draft.getType(sel[0]) != "Structure":
# direct creation
FreeCAD.ActiveDocument.openTransaction(
str(translate("Arch", "Create Structure")))
FreeCADGui.doCommand("import Arch")
# if selection contains structs and axes, make a system
st = Draft.getObjectsOfType(sel, "Structure")
ax = Draft.getObjectsOfType(sel, "Axis")
if st and ax:
FreeCADGui.doCommand("Arch.makeStructuralSystem(" +
ArchCommands.getStringList(st) + "," +
ArchCommands.getStringList(ax) + ")")
else:
# else, do normal structs
for obj in sel:
FreeCADGui.doCommand(
"Arch.makeStructure(FreeCAD.ActiveDocument." +
obj.Name + ")")
FreeCAD.ActiveDocument.commitTransaction()
FreeCAD.ActiveDocument.recompute()
return
# interactive mode
if hasattr(FreeCAD, "DraftWorkingPlane"):
FreeCAD.DraftWorkingPlane.setup()
import DraftTrackers
self.points = []
self.tracker = DraftTrackers.boxTracker()
self.tracker.width(self.Width)
self.tracker.height(self.Height)
self.tracker.length(self.Length)
self.tracker.on()
FreeCADGui.Snapper.getPoint(callback=self.getPoint,
movecallback=self.update,
extradlg=self.taskbox())
def Activated(self):
p = FreeCAD.ParamGet("User parameter:BaseApp/Preferences/Mod/Timber")
self.Length = p.GetFloat("BeamLength",1000)
self.Width = p.GetFloat("BeamWidth",100)
self.Height = p.GetFloat("BeamHeight",100)
#self.Profile = 0
self.continueCmd = False
self.DECIMALS = FreeCAD.ParamGet("User parameter:BaseApp/Preferences/Units").GetInt("Decimals",2)
import DraftGui
self.FORMAT = DraftGui.makeFormatSpec(self.DECIMALS,'Length')
"""
sel = FreeCADGui.Selection.getSelection()
if sel:
st = Draft.getObjectsOfType(sel,"Structure")
ax = Draft.getObjectsOfType(sel,"Axis")
if ax:
FreeCAD.ActiveDocument.openTransaction(str(translate("Arch","Create Structural System")))
FreeCADGui.addModule("Arch")
if st:
FreeCADGui.doCommand("Arch.makeStructuralSystem(" + ArchCommands.getStringList(st) + "," + ArchCommands.getStringList(ax) + ")")
else:
FreeCADGui.doCommand("Arch.makeStructuralSystem(axes=" + ArchCommands.getStringList(ax) + ")")
FreeCAD.ActiveDocument.commitTransaction()
FreeCAD.ActiveDocument.recompute()
return
elif not(ax) and not(st):
FreeCAD.ActiveDocument.openTransaction(str(translate("Arch","Create Structure")))
FreeCADGui.addModule("Arch")
for obj in sel:
FreeCADGui.doCommand("Arch.makeStructure(FreeCAD.ActiveDocument." + obj.Name + ")")
FreeCAD.ActiveDocument.commitTransaction()
FreeCAD.ActiveDocument.recompute()
return
"""
# interactive mode
if hasattr(FreeCAD,"DraftWorkingPlane"):
FreeCAD.DraftWorkingPlane.setup()
import DraftTrackers
self.points = []
self.tracker = DraftTrackers.boxTracker()
self.tracker.width(self.Width)
self.tracker.height(self.Height)
self.tracker.length(self.Length)
self.tracker.on()
FreeCADGui.Snapper.getPoint(callback=self.getPoint,movecallback=self.update,extradlg=self.taskbox())
def __init__(self,beam,originPoint,structure=None):
self.beam=beam
self.originPoint=originPoint
self.structure=structure
self.doc=FreeCAD.ActiveDocument
if self.doc == None:
FreeCAD.newDocument("Sans_Nom")
self.view = FreeCADGui.ActiveDocument.ActiveView
self.units=FreeCAD.Units.Quantity(1.0,FreeCAD.Units.Length)
self.points = []
#snapper starting
self.tracker = DraftTrackers.lineTracker()
self.tracker.on()
#ask for a point
FreeCADGui.Snapper.getPoint(last=self.originPoint,callback=self.getPoint,movecallback=self.update,title="Chagne the insertion Point")
def Activated(self):
global QtGui, QtCore
from PyQt4 import QtGui, QtCore
p = FreeCAD.ParamGet("User parameter:BaseApp/Preferences/Mod/Arch")
self.Length = p.GetFloat("StructureLength", 100)
self.Width = p.GetFloat("StructureWidth", 100)
self.Height = p.GetFloat("StructureHeight", 1000)
self.Profile = 0
self.continueCmd = False
sel = FreeCADGui.Selection.getSelection()
if sel:
# direct creation
FreeCAD.ActiveDocument.openTransaction(str(translate("Arch", "Create Structure")))
FreeCADGui.doCommand("import Arch")
# if selection contains structs and axes, make a system
st = Draft.getObjectsOfType(sel, "Structure")
ax = Draft.getObjectsOfType(sel, "Axis")
if st and ax:
FreeCADGui.doCommand(
"Arch.makeStructuralSystem("
+ ArchCommands.getStringList(st)
+ ","
+ ArchCommands.getStringList(ax)
+ ")"
)
else:
# else, do normal structs
for obj in sel:
FreeCADGui.doCommand("Arch.makeStructure(FreeCAD.ActiveDocument." + obj.Name + ")")
FreeCAD.ActiveDocument.commitTransaction()
FreeCAD.ActiveDocument.recompute()
else:
# interactive mode
if hasattr(FreeCAD, "DraftWorkingPlane"):
FreeCAD.DraftWorkingPlane.setup()
import DraftTrackers
self.points = []
self.tracker = DraftTrackers.boxTracker()
self.tracker.width(self.Width)
self.tracker.height(self.Height)
self.tracker.length(self.Length)
self.tracker.on()
FreeCADGui.Snapper.getPoint(callback=self.getPoint, movecallback=self.update, extradlg=self.taskbox())
def Activated(self):
global QtGui, QtCore
from PyQt4 import QtGui, QtCore
self.Length = 0.5
self.Width = 0.2
self.Height = 1
self.continueCmd = False
sel = FreeCADGui.Selection.getSelection()
if sel:
# direct creation
FreeCAD.ActiveDocument.openTransaction(
str(translate("Arch", "Create Structure")))
FreeCADGui.doCommand("import Arch")
# if selection contains structs and axes, make a system
st = Draft.getObjectsOfType(sel, "Structure")
ax = Draft.getObjectsOfType(sel, "Axis")
if st and ax:
FreeCADGui.doCommand("Arch.makeStructuralSystem(" +
ArchCommands.getStringList(st) + "," +
ArchCommands.getStringList(ax) + ")")
else:
# else, do normal structs
for obj in sel:
FreeCADGui.doCommand(
"Arch.makeStructure(FreeCAD.ActiveDocument." +
obj.Name + ")")
FreeCAD.ActiveDocument.commitTransaction()
FreeCAD.ActiveDocument.recompute()
else:
# interactive mode
import DraftTrackers
self.points = []
self.tracker = DraftTrackers.boxTracker()
self.tracker.width(self.Width)
self.tracker.height(self.Height)
self.tracker.length(self.Length)
self.tracker.on()
FreeCADGui.Snapper.getPoint(callback=self.getPoint,
movecallback=self.update,
extradlg=self.taskbox())
def __init__(self, view):
self.view = view
self.stack = []
self.impl=None
self.callback = self.view.addEventCallbackPivy(pvy.SoMouseButtonEvent.getClassTypeId(),self.getpoint)
self.callmouse=self.view.addEventCallbackPivy(pvy.SoLocation2Event.getClassTypeId(),self.getmousepoint)
self.distance=0
self.form=QtGui.QWidget()
self.label = QtGui.QLabel(self.form)
self.label.setGeometry(QtCore.QRect(30, 10, 66, 17))
self.lineEdit = QtGui.QLineEdit(self.form)
self.lineEdit.setGeometry(QtCore.QRect(100, 10, 113, 29))
self.label1 = QtGui.QLabel(self.form)
self.label1.setGeometry(QtCore.QRect(20, 45, 260, 17))
self.label.setText("Distance")
self.label1.setText("Select first point")
self.tracker = DraftTrackers.lineTracker(scolor=(1,0,0))
self.tracker.raiseTracker()
self.tracker.on()
FreeCADGui.Control.showDialog(self)
def Activated(self):
import FreeCADGui
from PySide import QtCore,QtGui
try:
import DraftTrackers
except Exception:
import draftguitools.gui_trackers as DraftTrackers
self.tracker = DraftTrackers.rectangleTracker()
self.basepoint = None
self.opposite = None
(filename, _filter) = QtGui.QFileDialog.getOpenFileName(QtGui.QApplication.activeWindow(),
translate("BIM","Select image"),
None,
translate("BIM","Image file (*.png *.jpg *.bmp)"))
if filename:
self.filename = filename
im = QtGui.QImage(self.filename)
self.proportion = float(im.height())/float(im.width())
if hasattr(FreeCADGui,"Snapper"):
FreeCADGui.Snapper.getPoint(callback=self.PointCallback,movecallback=self.MoveCallback)
def snap(self,screenpos,lastpoint=None,active=True,constrain=False,noTracker=False):
"""snap(screenpos,lastpoint=None,active=True,constrain=False,noTracker=False): returns a snapped
point from the given (x,y) screenpos (the position of the mouse cursor), active is to
activate active point snapping or not (passive), lastpoint is an optional
other point used to draw an imaginary segment and get additional snap locations. Constrain can
be True to constrain the point against the closest working plane axis.
Screenpos can be a list, a tuple or a coin.SbVec2s object. If noTracker is True,
the tracking line is not displayed."""
global Part, DraftGeomUtils
import Part, DraftGeomUtils
if not hasattr(self,"toolbar"):
self.makeSnapToolBar()
mw = DraftGui.getMainWindow()
bt = mw.findChild(QtGui.QToolBar,"Draft Snap")
if not bt:
mw.addToolBar(self.toolbar)
else:
if Draft.getParam("showSnapBar"):
bt.show()
def cstr(point):
"constrains if needed"
if constrain or self.mask:
fpt = self.constrain(point,lastpoint)
else:
self.unconstrain()
fpt = point
if self.radiusTracker:
self.radiusTracker.update(fpt)
return fpt
snaps = []
self.snapInfo = None
# type conversion if needed
if isinstance(screenpos,list):
screenpos = tuple(screenpos)
elif isinstance(screenpos,coin.SbVec2s):
screenpos = tuple(screenpos.getValue())
elif not isinstance(screenpos,tuple):
print "snap needs valid screen position (list, tuple or sbvec2s)"
return None
# setup trackers if needed
self.setTrackers()
# getting current snap Radius
self.radius = self.getScreenDist(Draft.getParam("snapRange"),screenpos)
if self.radiusTracker:
self.radiusTracker.update(self.radius)
self.radiusTracker.off()
# activate snap
oldActive = False
if Draft.getParam("alwaysSnap"):
oldActive = active
active = True
if not self.active:
active = False
self.setCursor('passive')
if self.tracker:
self.tracker.off()
if self.extLine:
self.extLine.off()
if self.trackLine:
self.trackLine.off()
if self.dim1:
self.dim1.off()
if self.dim2:
self.dim2.off()
point = self.getApparentPoint(screenpos[0],screenpos[1])
# setup a track line if we got a last point
if lastpoint:
if not self.trackLine:
self.trackLine = DraftTrackers.lineTracker()
self.trackLine.p1(lastpoint)
# check if we snapped to something
self.snapInfo = Draft.get3DView().getObjectInfo((screenpos[0],screenpos[1]))
# checking if parallel to one of the edges of the last objects or to a polar direction
if active:
eline = None
point,eline = self.snapToPolar(point,lastpoint)
point,eline = self.snapToExtensions(point,lastpoint,constrain,eline)
if not self.snapInfo:
# nothing has been snapped, check fro grid snap
if active:
point = self.snapToGrid(point)
fp = cstr(point)
if self.trackLine and lastpoint and (not noTracker):
self.trackLine.p2(fp)
self.trackLine.on()
# set the arch point tracking
if self.lastArchPoint:
self.setArchDims(self.lastArchPoint,fp)
return fp
else:
# we have an object to snap to
obj = FreeCAD.ActiveDocument.getObject(self.snapInfo['Object'])
if not obj:
return cstr(point)
self.lastSnappedObject = obj
if hasattr(obj.ViewObject,"Selectable"):
if not obj.ViewObject.Selectable:
return cstr(point)
if not active:
# passive snapping
snaps = [self.snapToVertex(self.snapInfo)]
else:
# first stick to the snapped object
s = self.snapToVertex(self.snapInfo)
if s:
point = s[0]
# active snapping
comp = self.snapInfo['Component']
if (Draft.getType(obj) == "Wall") and not oldActive:
# special snapping for wall: only to its base shape (except when CTRL is pressed)
edges = []
for o in [obj]+obj.Additions:
if Draft.getType(o) == "Wall":
if o.Base:
edges.extend(o.Base.Shape.Edges)
for edge in edges:
snaps.extend(self.snapToEndpoints(edge))
snaps.extend(self.snapToMidpoint(edge))
snaps.extend(self.snapToPerpendicular(edge,lastpoint))
snaps.extend(self.snapToIntersection(edge))
snaps.extend(self.snapToElines(edge,eline))
elif (Draft.getType(obj) == "Structure") and not oldActive:
# special snapping for struct: only to its base point (except when CTRL is pressed)
if obj.Base:
for edge in obj.Base.Shape.Edges:
snaps.extend(self.snapToEndpoints(edge))
snaps.extend(self.snapToMidpoint(edge))
snaps.extend(self.snapToPerpendicular(edge,lastpoint))
snaps.extend(self.snapToIntersection(edge))
snaps.extend(self.snapToElines(edge,eline))
else:
b = obj.Placement.Base
snaps.append([b,'endpoint',b])
elif obj.isDerivedFrom("Part::Feature"):
if Draft.getType(obj) == "Polygon":
snaps.extend(self.snapToPolygon(obj))
if (not self.maxEdges) or (len(obj.Edges) <= self.maxEdges):
if "Edge" in comp:
# we are snapping to an edge
en = int(comp[4:])-1
if len(obj.Shape.Edges) > en:
edge = obj.Shape.Edges[en]
snaps.extend(self.snapToEndpoints(edge))
snaps.extend(self.snapToMidpoint(edge))
snaps.extend(self.snapToPerpendicular(edge,lastpoint))
#snaps.extend(self.snapToOrtho(edge,lastpoint,constrain)) # now part of snapToPolar
snaps.extend(self.snapToIntersection(edge))
snaps.extend(self.snapToElines(edge,eline))
if DraftGeomUtils.geomType(edge) == "Circle":
# the edge is an arc, we have extra options
snaps.extend(self.snapToAngles(edge))
snaps.extend(self.snapToCenter(edge))
elif "Vertex" in comp:
# directly snapped to a vertex
snaps.append(self.snapToVertex(self.snapInfo,active=True))
elif comp == '':
# workaround for the new view provider
snaps.append(self.snapToVertex(self.snapInfo,active=True))
else:
# all other cases (face, etc...) default to passive snap
snapArray = [self.snapToVertex(self.snapInfo)]
elif Draft.getType(obj) == "Dimension":
# for dimensions we snap to their 3 points
for pt in [obj.Start,obj.End,obj.Dimline]:
snaps.append([pt,'endpoint',pt])
elif Draft.getType(obj) == "Mesh":
# for meshes we only snap to vertices
snaps.extend(self.snapToEndpoints(obj.Mesh))
elif Draft.getType(obj) == "Points":
# for points we only snap to points
snaps.extend(self.snapToEndpoints(obj.Points))
# updating last objects list
if not self.lastObj[1]:
self.lastObj[1] = obj.Name
elif self.lastObj[1] != obj.Name:
self.lastObj[0] = self.lastObj[1]
self.lastObj[1] = obj.Name
if not snaps:
return cstr(point)
# calculating the nearest snap point
shortest = 1000000000000000000
origin = Vector(self.snapInfo['x'],self.snapInfo['y'],self.snapInfo['z'])
winner = [Vector(0,0,0),None,Vector(0,0,0)]
for snap in snaps:
if (not snap) or (snap[0] == None):
print "debug: Snapper: invalid snap point: ",snaps
else:
delta = snap[0].sub(origin)
if delta.Length < shortest:
shortest = delta.Length
winner = snap
# see if we are out of the max radius, if any
if self.radius:
dv = point.sub(winner[2])
if (dv.Length > self.radius):
if (not oldActive) and self.isEnabled("passive"):
winner = self.snapToVertex(self.snapInfo)
# setting the cursors
if self.tracker:
self.tracker.setCoords(winner[2])
self.tracker.setMarker(self.mk[winner[1]])
self.tracker.on()
# setting the trackline
fp = cstr(winner[2])
if self.trackLine and lastpoint:
self.trackLine.p2(fp)
self.trackLine.on()
# set the cursor
self.setCursor(winner[1])
# set the arch point tracking
if self.lastArchPoint:
self.setArchDims(self.lastArchPoint,fp)
if Draft.getType(obj) in ["Wall","Structure"]:
self.lastArchPoint = winner[2]
else:
self.lastArchPoint = None
# return the final point
return fp
def getPoint(self,
last=None,
callback=None,
movecallback=None,
extradlg=None):
"""
getPoint([last],[callback],[movecallback],[extradlg]) : gets a 3D point
from the screen. You can provide an existing point, in that case additional
snap options and a tracker are available.
You can also pass a function as callback, which will get called
with the resulting point as argument, when a point is clicked, and optionally
another callback which gets called when the mouse is moved.
If the operation gets cancelled (the user pressed Escape), no point is returned.
Example:
def cb(point):
if point:
print "got a 3D point: ",point
FreeCADGui.Snapper.getPoint(callback=cb)
If the callback function accepts more than one argument, it will also receive
the last snapped object. Finally, a pyqt dialog can be passed as extra taskbox.
"""
import inspect
self.pt = None
self.lastSnappedObject = None
self.ui = FreeCADGui.draftToolBar
self.view = Draft.get3DView()
# setting a track line if we got an existing point
if last:
if not self.trackLine:
self.trackLine = DraftTrackers.lineTracker()
self.trackLine.p1(last)
self.trackLine.on()
def move(event_cb):
event = event_cb.getEvent()
mousepos = event.getPosition()
ctrl = event.wasCtrlDown()
shift = event.wasShiftDown()
self.pt = FreeCADGui.Snapper.snap(mousepos,
lastpoint=last,
active=ctrl,
constrain=shift)
if hasattr(FreeCAD, "DraftWorkingPlane"):
self.ui.displayPoint(self.pt,
last,
plane=FreeCAD.DraftWorkingPlane,
mask=FreeCADGui.Snapper.affinity)
if self.trackLine:
self.trackLine.p2(self.pt)
if movecallback:
movecallback(self.pt)
def getcoords(point, relative=False):
self.pt = point
if relative and last and hasattr(FreeCAD, "DraftWorkingPlane"):
v = FreeCAD.DraftWorkingPlane.getGlobalCoords(point)
self.pt = last.add(v)
accept()
def click(event_cb):
event = event_cb.getEvent()
if event.getButton() == 1:
if event.getState() == coin.SoMouseButtonEvent.DOWN:
accept()
def accept():
self.view.removeEventCallbackPivy(
coin.SoMouseButtonEvent.getClassTypeId(), self.callbackClick)
self.view.removeEventCallbackPivy(
coin.SoLocation2Event.getClassTypeId(), self.callbackMove)
obj = FreeCADGui.Snapper.lastSnappedObject
FreeCADGui.Snapper.off()
self.ui.offUi()
if self.trackLine:
self.trackLine.off()
if callback:
if len(inspect.getargspec(callback).args) > 2:
callback(self.pt, obj)
else:
callback(self.pt)
self.pt = None
def cancel():
self.view.removeEventCallbackPivy(
coin.SoMouseButtonEvent.getClassTypeId(), self.callbackClick)
self.view.removeEventCallbackPivy(
coin.SoLocation2Event.getClassTypeId(), self.callbackMove)
FreeCADGui.Snapper.off()
self.ui.offUi()
if self.trackLine:
self.trackLine.off()
if callback:
callback(None)
# adding callback functions
self.ui.pointUi(cancel=cancel,
getcoords=getcoords,
extra=extradlg,
rel=bool(last))
self.callbackClick = self.view.addEventCallbackPivy(
coin.SoMouseButtonEvent.getClassTypeId(), click)
self.callbackMove = self.view.addEventCallbackPivy(
coin.SoLocation2Event.getClassTypeId(), move)
def snap(self,screenpos,lastpoint=None,active=True,constrain=False):
"""snap(screenpos,lastpoint=None,active=True,constrain=False): returns a snapped
point from the given (x,y) screenpos (the position of the mouse cursor), active is to
activate active point snapping or not (passive), lastpoint is an optional
other point used to draw an imaginary segment and get additional snap locations. Constrain can
be True to constrain the point against the closest working plane axis.
Screenpos can be a list, a tuple or a coin.SbVec2s object."""
global Part,fcgeo
import Part
from draftlibs import fcgeo
if not hasattr(self,"toolbar"):
self.makeSnapToolBar()
mw = getMainWindow()
bt = mw.findChild(QtGui.QToolBar,"Draft Snap")
if not bt:
mw.addToolBar(self.toolbar)
else:
if Draft.getParam("showSnapBar"):
bt.show()
def cstr(point):
"constrains if needed"
if constrain:
return self.constrain(point,lastpoint)
else:
self.unconstrain()
return point
snaps = []
self.snapInfo = None
# type conversion if needed
if isinstance(screenpos,list):
screenpos = tuple(screenpos)
elif isinstance(screenpos,coin.SbVec2s):
screenpos = tuple(screenpos.getValue())
elif not isinstance(screenpos,tuple):
print "snap needs valid screen position (list, tuple or sbvec2s)"
return None
# setup trackers if needed
v = Draft.get3DView()
if v in self.trackers[0]:
i = self.trackers[0].index(v)
self.grid = self.trackers[1][i]
self.tracker = self.trackers[2][i]
self.extLine = self.trackers[3][i]
else:
if Draft.getParam("grid"):
self.grid = DraftTrackers.gridTracker()
else:
self.grid = None
self.tracker = DraftTrackers.snapTracker()
self.extLine = DraftTrackers.lineTracker(dotted=True)
self.trackers[0].append(v)
self.trackers[1].append(self.grid)
self.trackers[2].append(self.tracker)
self.trackers[3].append(self.extLine)
# getting current snap Radius
if not self.radius:
self.radius = self.getScreenDist(Draft.getParam("snapRange"),screenpos)
# set the grid
if self.grid and Draft.getParam("grid"):
self.grid.set()
# activate snap
oldActive = False
if Draft.getParam("alwaysSnap"):
oldActive = active
active = True
if not self.active:
active = False
self.setCursor('passive')
if self.tracker:
self.tracker.off()
if self.extLine:
self.extLine.off()
point = self.getApparentPoint(screenpos[0],screenpos[1])
# check if we snapped to something
self.snapInfo = Draft.get3DView().getObjectInfo((screenpos[0],screenpos[1]))
# checking if parallel to one of the edges of the last objects or to a polar direction
if active:
eline = None
point,eline = self.snapToPolar(point,lastpoint)
point,eline = self.snapToExtensions(point,lastpoint,constrain,eline)
if not self.snapInfo:
# nothing has been snapped, check fro grid snap
if active:
point = self.snapToGrid(point)
return cstr(point)
else:
# we have an object to snap to
obj = FreeCAD.ActiveDocument.getObject(self.snapInfo['Object'])
if not obj:
return cstr(point)
self.lastSnappedObject = obj
if hasattr(obj.ViewObject,"Selectable"):
if not obj.ViewObject.Selectable:
return cstr(point)
if not active:
# passive snapping
snaps = [self.snapToVertex(self.snapInfo)]
else:
# active snapping
comp = self.snapInfo['Component']
if (Draft.getType(obj) == "Wall") and not oldActive:
edges = []
for o in [obj]+obj.Additions:
if Draft.getType(o) == "Wall":
if o.Base:
edges.extend(o.Base.Shape.Edges)
for edge in edges:
snaps.extend(self.snapToEndpoints(edge))
snaps.extend(self.snapToMidpoint(edge))
snaps.extend(self.snapToPerpendicular(edge,lastpoint))
snaps.extend(self.snapToIntersection(edge))
snaps.extend(self.snapToElines(edge,eline))
elif obj.isDerivedFrom("Part::Feature"):
if (not self.maxEdges) or (len(obj.Edges) <= self.maxEdges):
if "Edge" in comp:
# we are snapping to an edge
edge = obj.Shape.Edges[int(comp[4:])-1]
snaps.extend(self.snapToEndpoints(edge))
snaps.extend(self.snapToMidpoint(edge))
snaps.extend(self.snapToPerpendicular(edge,lastpoint))
#snaps.extend(self.snapToOrtho(edge,lastpoint,constrain)) # now part of snapToPolar
snaps.extend(self.snapToIntersection(edge))
snaps.extend(self.snapToElines(edge,eline))
if isinstance (edge.Curve,Part.Circle):
# the edge is an arc, we have extra options
snaps.extend(self.snapToAngles(edge))
snaps.extend(self.snapToCenter(edge))
elif "Vertex" in comp:
# directly snapped to a vertex
snaps.append(self.snapToVertex(self.snapInfo,active=True))
elif comp == '':
# workaround for the new view provider
snaps.append(self.snapToVertex(self.snapInfo,active=True))
else:
# all other cases (face, etc...) default to passive snap
snapArray = [self.snapToVertex(self.snapInfo)]
elif Draft.getType(obj) == "Dimension":
# for dimensions we snap to their 3 points
for pt in [obj.Start,obj.End,obj.Dimline]:
snaps.append([pt,'endpoint',pt])
elif Draft.getType(obj) == "Mesh":
# for meshes we only snap to vertices
snaps.extend(self.snapToEndpoints(obj.Mesh))
elif Draft.getType(obj) == "Points":
# for points we only snap to points
snaps.extend(self.snapToEndpoints(obj.Points))
# updating last objects list
if not self.lastObj[1]:
self.lastObj[1] = obj.Name
elif self.lastObj[1] != obj.Name:
self.lastObj[0] = self.lastObj[1]
self.lastObj[1] = obj.Name
if not snaps:
return point
# calculating the nearest snap point
shortest = 1000000000000000000
origin = Vector(self.snapInfo['x'],self.snapInfo['y'],self.snapInfo['z'])
winner = [Vector(0,0,0),None,Vector(0,0,0)]
for snap in snaps:
# if snap[0] == None: print "debug: Snapper: 'i[0]' is 'None'"
delta = snap[0].sub(origin)
if delta.Length < shortest:
shortest = delta.Length
winner = snap
# see if we are out of the max radius, if any
if self.radius:
dv = point.sub(winner[2])
if (dv.Length > self.radius):
if (not oldActive) and self.isEnabled("passive"):
winner = self.snapToVertex(self.snapInfo)
# setting the cursors
if self.tracker:
self.tracker.setCoords(winner[2])
self.tracker.setMarker(self.mk[winner[1]])
self.tracker.on()
self.setCursor(winner[1])
# return the final point
return cstr(winner[2])
def askInsPoint(self):
Console.PrintMessage("##BeamTracker## Ask ins point\r\n")
self.tracker=DraftTrackers.lineTracker()
FreeCADGui.Snapper.getPoint(callback=self.getSartPoint)
def Activated(self):
self.tracker = DraftTrackers.lineTracker()
self.tracker.on()
self.objList = FreeCADGui.Selection.getSelection()
FreeCADGui.Snapper.getPoint(callback=self.getBasePoint,
title="Base Point")
def snap(self,
screenpos,
lastpoint=None,
active=True,
constrain=False,
noTracker=False):
"""snap(screenpos,lastpoint=None,active=True,constrain=False,noTracker=False): returns a snapped
point from the given (x,y) screenpos (the position of the mouse cursor), active is to
activate active point snapping or not (passive), lastpoint is an optional
other point used to draw an imaginary segment and get additional snap locations. Constrain can
be True to constrain the point against the closest working plane axis.
Screenpos can be a list, a tuple or a coin.SbVec2s object. If noTracker is True,
the tracking line is not displayed."""
global Part, DraftGeomUtils
import Part, DraftGeomUtils
if not hasattr(self, "toolbar"):
self.makeSnapToolBar()
mw = DraftGui.getMainWindow()
bt = mw.findChild(QtGui.QToolBar, "Draft Snap")
if not bt:
mw.addToolBar(self.toolbar)
else:
if Draft.getParam("showSnapBar"):
bt.show()
def cstr(point):
"constrains if needed"
if constrain or self.mask:
fpt = self.constrain(point, lastpoint)
else:
self.unconstrain()
fpt = point
if self.radiusTracker:
self.radiusTracker.update(fpt)
return fpt
snaps = []
self.snapInfo = None
# type conversion if needed
if isinstance(screenpos, list):
screenpos = tuple(screenpos)
elif isinstance(screenpos, coin.SbVec2s):
screenpos = tuple(screenpos.getValue())
elif not isinstance(screenpos, tuple):
print "snap needs valid screen position (list, tuple or sbvec2s)"
return None
# setup trackers if needed
self.setTrackers()
# getting current snap Radius
self.radius = self.getScreenDist(Draft.getParam("snapRange"),
screenpos)
if self.radiusTracker:
self.radiusTracker.update(self.radius)
self.radiusTracker.off()
# activate snap
oldActive = False
if Draft.getParam("alwaysSnap"):
oldActive = active
active = True
if not self.active:
active = False
self.setCursor('passive')
if self.tracker:
self.tracker.off()
if self.extLine:
self.extLine.off()
if self.trackLine:
self.trackLine.off()
if self.dim1:
self.dim1.off()
if self.dim2:
self.dim2.off()
point = self.getApparentPoint(screenpos[0], screenpos[1])
# setup a track line if we got a last point
if lastpoint:
if not self.trackLine:
self.trackLine = DraftTrackers.lineTracker()
self.trackLine.p1(lastpoint)
# check if we snapped to something
self.snapInfo = Draft.get3DView().getObjectInfo(
(screenpos[0], screenpos[1]))
# checking if parallel to one of the edges of the last objects or to a polar direction
if active:
eline = None
point, eline = self.snapToPolar(point, lastpoint)
point, eline = self.snapToExtensions(point, lastpoint, constrain,
eline)
if not self.snapInfo:
# nothing has been snapped, check fro grid snap
if active:
point = self.snapToGrid(point)
fp = cstr(point)
if self.trackLine and lastpoint and (not noTracker):
self.trackLine.p2(fp)
self.trackLine.on()
# set the arch point tracking
if self.lastArchPoint:
self.setArchDims(self.lastArchPoint, fp)
return fp
else:
# we have an object to snap to
obj = FreeCAD.ActiveDocument.getObject(self.snapInfo['Object'])
if not obj:
return cstr(point)
self.lastSnappedObject = obj
if hasattr(obj.ViewObject, "Selectable"):
if not obj.ViewObject.Selectable:
return cstr(point)
if not active:
# passive snapping
snaps = [self.snapToVertex(self.snapInfo)]
else:
# first stick to the snapped object
s = self.snapToVertex(self.snapInfo)
if s:
point = s[0]
# active snapping
comp = self.snapInfo['Component']
if (Draft.getType(obj) == "Wall") and not oldActive:
# special snapping for wall: only to its base shape (except when CTRL is pressed)
edges = []
for o in [obj] + obj.Additions:
if Draft.getType(o) == "Wall":
if o.Base:
edges.extend(o.Base.Shape.Edges)
for edge in edges:
snaps.extend(self.snapToEndpoints(edge))
snaps.extend(self.snapToMidpoint(edge))
snaps.extend(self.snapToPerpendicular(edge, lastpoint))
snaps.extend(self.snapToIntersection(edge))
snaps.extend(self.snapToElines(edge, eline))
elif (Draft.getType(obj) == "Structure") and not oldActive:
# special snapping for struct: only to its base point (except when CTRL is pressed)
if obj.Base:
for edge in o.Base.Shape.Edges:
snaps.extend(self.snapToEndpoints(edge))
snaps.extend(self.snapToMidpoint(edge))
snaps.extend(
self.snapToPerpendicular(edge, lastpoint))
snaps.extend(self.snapToIntersection(edge))
snaps.extend(self.snapToElines(edge, eline))
else:
b = obj.Placement.Base
snaps.append([b, 'endpoint', b])
elif obj.isDerivedFrom("Part::Feature"):
if Draft.getType(obj) == "Polygon":
snaps.extend(self.snapToPolygon(obj))
if (not self.maxEdges) or (len(obj.Edges) <=
self.maxEdges):
if "Edge" in comp:
# we are snapping to an edge
en = int(comp[4:]) - 1
if len(obj.Shape.Edges) > en:
edge = obj.Shape.Edges[en]
snaps.extend(self.snapToEndpoints(edge))
snaps.extend(self.snapToMidpoint(edge))
snaps.extend(
self.snapToPerpendicular(edge, lastpoint))
#snaps.extend(self.snapToOrtho(edge,lastpoint,constrain)) # now part of snapToPolar
snaps.extend(self.snapToIntersection(edge))
snaps.extend(self.snapToElines(edge, eline))
if DraftGeomUtils.geomType(edge) == "Circle":
# the edge is an arc, we have extra options
snaps.extend(self.snapToAngles(edge))
snaps.extend(self.snapToCenter(edge))
elif "Vertex" in comp:
# directly snapped to a vertex
snaps.append(
self.snapToVertex(self.snapInfo, active=True))
elif comp == '':
# workaround for the new view provider
snaps.append(
self.snapToVertex(self.snapInfo, active=True))
else:
# all other cases (face, etc...) default to passive snap
snapArray = [self.snapToVertex(self.snapInfo)]
elif Draft.getType(obj) == "Dimension":
# for dimensions we snap to their 3 points
for pt in [obj.Start, obj.End, obj.Dimline]:
snaps.append([pt, 'endpoint', pt])
elif Draft.getType(obj) == "Mesh":
# for meshes we only snap to vertices
snaps.extend(self.snapToEndpoints(obj.Mesh))
elif Draft.getType(obj) == "Points":
# for points we only snap to points
snaps.extend(self.snapToEndpoints(obj.Points))
# updating last objects list
if not self.lastObj[1]:
self.lastObj[1] = obj.Name
elif self.lastObj[1] != obj.Name:
self.lastObj[0] = self.lastObj[1]
self.lastObj[1] = obj.Name
if not snaps:
return cstr(point)
# calculating the nearest snap point
shortest = 1000000000000000000
origin = Vector(self.snapInfo['x'], self.snapInfo['y'],
self.snapInfo['z'])
winner = [Vector(0, 0, 0), None, Vector(0, 0, 0)]
for snap in snaps:
if (not snap) or (snap[0] == None):
print "debug: Snapper: invalid snap point: ", snaps
else:
delta = snap[0].sub(origin)
if delta.Length < shortest:
shortest = delta.Length
winner = snap
# see if we are out of the max radius, if any
if self.radius:
dv = point.sub(winner[2])
if (dv.Length > self.radius):
if (not oldActive) and self.isEnabled("passive"):
winner = self.snapToVertex(self.snapInfo)
# setting the cursors
if self.tracker:
self.tracker.setCoords(winner[2])
self.tracker.setMarker(self.mk[winner[1]])
self.tracker.on()
# setting the trackline
fp = cstr(winner[2])
if self.trackLine and lastpoint:
self.trackLine.p2(fp)
self.trackLine.on()
# set the cursor
self.setCursor(winner[1])
# set the arch point tracking
if self.lastArchPoint:
self.setArchDims(self.lastArchPoint, fp)
if Draft.getType(obj) in ["Wall", "Structure"]:
self.lastArchPoint = winner[2]
else:
self.lastArchPoint = None
# return the final point
return fp
def constrain(self, point, basepoint=None, axis=None):
'''constrain(point,basepoint=None,axis=None: Returns a
constrained point. Axis can be "x","y" or "z" or a custom vector. If None,
the closest working plane axis will be picked.
Basepoint is the base point used to figure out from where the point
must be constrained. If no basepoint is given, the current point is
used as basepoint.'''
# without the Draft module fully loaded, no axes system!"
if not hasattr(FreeCAD, "DraftWorkingPlane"):
return point
point = Vector(point)
# setup trackers if needed
if not self.constrainLine:
self.constrainLine = DraftTrackers.lineTracker(dotted=True)
# setting basepoint
if not basepoint:
if not self.basepoint:
self.basepoint = point
else:
self.basepoint = basepoint
delta = point.sub(self.basepoint)
# setting constraint axis
if self.mask:
self.affinity = self.mask
if not self.affinity:
self.affinity = FreeCAD.DraftWorkingPlane.getClosestAxis(delta)
if isinstance(axis, FreeCAD.Vector):
self.constraintAxis = axis
elif axis == "x":
self.constraintAxis = FreeCAD.DraftWorkingPlane.u
elif axis == "y":
self.constraintAxis = FreeCAD.DraftWorkingPlane.v
elif axis == "z":
self.constraintAxis = FreeCAD.DraftWorkingPlane.axis
else:
if self.affinity == "x":
self.constraintAxis = FreeCAD.DraftWorkingPlane.u
elif self.affinity == "y":
self.constraintAxis = FreeCAD.DraftWorkingPlane.v
else:
self.constraintAxis = FreeCAD.DraftWorkingPlane.axis
# calculating constrained point
cdelta = DraftVecUtils.project(delta, self.constraintAxis)
npoint = self.basepoint.add(cdelta)
# setting constrain line
if self.constrainLine:
if point != npoint:
self.constrainLine.p1(point)
self.constrainLine.p2(npoint)
self.constrainLine.on()
else:
self.constrainLine.off()
return npoint
