808 lines
36 KiB
Python
808 lines
36 KiB
Python
#***************************************************************************
|
|
#* *
|
|
#* Copyright (c) 2011 *
|
|
#* Yorik van Havre <yorik@uncreated.net> *
|
|
#* *
|
|
#* 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. *
|
|
#* *
|
|
#* This program 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 this program; if not, write to the Free Software *
|
|
#* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 *
|
|
#* USA *
|
|
#* *
|
|
#***************************************************************************
|
|
|
|
__title__="FreeCAD Arch Component"
|
|
__author__ = "Yorik van Havre"
|
|
__url__ = "http://www.freecadweb.org"
|
|
|
|
# Possible roles for IFC objects
|
|
Roles = ['Undefined','Beam','Chimney','Column','Covering','Curtain Wall',
|
|
'Door','Foundation','Furniture','Hydro Equipment','Electric Equipment',
|
|
'Member','Plate','Railing','Ramp','Ramp Flight','Rebar','Pile','Roof','Shading Device','Slab','Space',
|
|
'Stair','Stair Flight','Tendon','Wall','Wall Layer','Window']
|
|
|
|
import FreeCAD,Draft
|
|
from FreeCAD import Vector
|
|
if FreeCAD.GuiUp:
|
|
import FreeCADGui
|
|
from PySide import QtGui,QtCore
|
|
from DraftTools import translate
|
|
else:
|
|
def translate(ctxt,txt):
|
|
return txt
|
|
|
|
|
|
def addToComponent(compobject,addobject,mod=None):
|
|
'''addToComponent(compobject,addobject,mod): adds addobject
|
|
to the given component. Default is in "Additions", "Objects" or
|
|
"Components", the first one that exists in the component. Mod
|
|
can be set to one of those attributes ("Objects", Base", etc...)
|
|
to override the default.'''
|
|
import Draft
|
|
if compobject == addobject: return
|
|
# first check zis already there
|
|
found = False
|
|
attribs = ["Additions","Objects","Components","Subtractions","Base"]
|
|
for a in attribs:
|
|
if hasattr(compobject,a):
|
|
if a == "Base":
|
|
if addobject == getattr(compobject,a):
|
|
found = True
|
|
else:
|
|
if addobject in getattr(compobject,a):
|
|
found = True
|
|
if not found:
|
|
if mod:
|
|
if hasattr(compobject,mod):
|
|
if mod == "Base":
|
|
setattr(compobject,mod,addobject)
|
|
addobject.ViewObject.hide()
|
|
elif mod == "Axes":
|
|
if Draft.getType(addobject) == "Axis":
|
|
l = getattr(compobject,mod)
|
|
l.append(addobject)
|
|
setattr(compobject,mod,l)
|
|
else:
|
|
l = getattr(compobject,mod)
|
|
l.append(addobject)
|
|
setattr(compobject,mod,l)
|
|
if mod != "Objects":
|
|
addobject.ViewObject.hide()
|
|
else:
|
|
for a in attribs[:3]:
|
|
if hasattr(compobject,a):
|
|
l = getattr(compobject,a)
|
|
l.append(addobject)
|
|
setattr(compobject,a,l)
|
|
addobject.ViewObject.hide()
|
|
break
|
|
|
|
|
|
def removeFromComponent(compobject,subobject):
|
|
'''removeFromComponent(compobject,subobject): subtracts subobject
|
|
from the given component. If the subobject is already part of the
|
|
component (as addition, subtraction, etc... it is removed. Otherwise,
|
|
it is added as a subtraction.'''
|
|
if compobject == subobject: return
|
|
found = False
|
|
attribs = ["Additions","Subtractions","Objects","Components","Base","Axes","Fixtures"]
|
|
for a in attribs:
|
|
if hasattr(compobject,a):
|
|
if a == "Base":
|
|
if subobject == getattr(compobject,a):
|
|
setattr(compobject,a,None)
|
|
subobject.ViewObject.show()
|
|
found = True
|
|
else:
|
|
if subobject in getattr(compobject,a):
|
|
l = getattr(compobject,a)
|
|
l.remove(subobject)
|
|
setattr(compobject,a,l)
|
|
subobject.ViewObject.show()
|
|
found = True
|
|
if not found:
|
|
if hasattr(compobject,"Subtractions"):
|
|
l = compobject.Subtractions
|
|
l.append(subobject)
|
|
compobject.Subtractions = l
|
|
if (Draft.getType(subobject) != "Window") and (not Draft.isClone(subobject,"Window",True)):
|
|
subobject.ViewObject.hide()
|
|
|
|
|
|
class SelectionTaskPanel:
|
|
"""A temp taks panel to wait for a selection"""
|
|
def __init__(self):
|
|
self.form = QtGui.QLabel()
|
|
self.form.setText(QtGui.QApplication.translate("Arch", "Please select a base object", None, QtGui.QApplication.UnicodeUTF8))
|
|
|
|
def getStandardButtons(self):
|
|
return int(QtGui.QDialogButtonBox.Cancel)
|
|
|
|
def reject(self):
|
|
if hasattr(FreeCAD,"ArchObserver"):
|
|
FreeCADGui.Selection.removeObserver(FreeCAD.ArchObserver)
|
|
del FreeCAD.ArchObserver
|
|
return True
|
|
|
|
|
|
class ComponentTaskPanel:
|
|
'''The default TaskPanel for all Arch components'''
|
|
def __init__(self):
|
|
# the panel has a tree widget that contains categories
|
|
# for the subcomponents, such as additions, subtractions.
|
|
# the categories are shown only if they are not empty.
|
|
|
|
self.obj = None
|
|
self.attribs = ["Base","Additions","Subtractions","Objects","Components","Axes","Fixtures","Armatures"]
|
|
self.form = QtGui.QWidget()
|
|
self.form.setObjectName("TaskPanel")
|
|
self.grid = QtGui.QGridLayout(self.form)
|
|
self.grid.setObjectName("grid")
|
|
self.title = QtGui.QLabel(self.form)
|
|
self.grid.addWidget(self.title, 0, 0, 1, 2)
|
|
|
|
# tree
|
|
self.tree = QtGui.QTreeWidget(self.form)
|
|
self.grid.addWidget(self.tree, 1, 0, 1, 2)
|
|
self.tree.setColumnCount(1)
|
|
self.tree.header().hide()
|
|
|
|
# buttons
|
|
self.addButton = QtGui.QPushButton(self.form)
|
|
self.addButton.setObjectName("addButton")
|
|
self.addButton.setIcon(QtGui.QIcon(":/icons/Arch_Add.svg"))
|
|
self.grid.addWidget(self.addButton, 3, 0, 1, 1)
|
|
self.addButton.setEnabled(False)
|
|
|
|
self.delButton = QtGui.QPushButton(self.form)
|
|
self.delButton.setObjectName("delButton")
|
|
self.delButton.setIcon(QtGui.QIcon(":/icons/Arch_Remove.svg"))
|
|
self.grid.addWidget(self.delButton, 3, 1, 1, 1)
|
|
self.delButton.setEnabled(False)
|
|
|
|
QtCore.QObject.connect(self.addButton, QtCore.SIGNAL("clicked()"), self.addElement)
|
|
QtCore.QObject.connect(self.delButton, QtCore.SIGNAL("clicked()"), self.removeElement)
|
|
QtCore.QObject.connect(self.tree, QtCore.SIGNAL("itemClicked(QTreeWidgetItem*,int)"), self.check)
|
|
QtCore.QObject.connect(self.tree, QtCore.SIGNAL("itemDoubleClicked(QTreeWidgetItem *,int)"), self.editObject)
|
|
self.update()
|
|
|
|
def isAllowedAlterSelection(self):
|
|
return True
|
|
|
|
def isAllowedAlterView(self):
|
|
return True
|
|
|
|
def getStandardButtons(self):
|
|
return int(QtGui.QDialogButtonBox.Ok)
|
|
|
|
def check(self,wid,col):
|
|
if not wid.parent():
|
|
self.delButton.setEnabled(False)
|
|
if self.obj:
|
|
sel = FreeCADGui.Selection.getSelection()
|
|
if sel:
|
|
if not(self.obj in sel):
|
|
self.addButton.setEnabled(True)
|
|
else:
|
|
self.delButton.setEnabled(True)
|
|
self.addButton.setEnabled(False)
|
|
|
|
def getIcon(self,obj):
|
|
if hasattr(obj.ViewObject,"Proxy"):
|
|
return QtGui.QIcon(obj.ViewObject.Proxy.getIcon())
|
|
elif obj.isDerivedFrom("Sketcher::SketchObject"):
|
|
return QtGui.QIcon(":/icons/Sketcher_Sketch.svg")
|
|
else:
|
|
return QtGui.QIcon(":/icons/Tree_Part.svg")
|
|
|
|
def update(self):
|
|
'fills the treewidget'
|
|
self.tree.clear()
|
|
dirIcon = QtGui.QApplication.style().standardIcon(QtGui.QStyle.SP_DirIcon)
|
|
for a in self.attribs:
|
|
setattr(self,"tree"+a,QtGui.QTreeWidgetItem(self.tree))
|
|
c = getattr(self,"tree"+a)
|
|
c.setIcon(0,dirIcon)
|
|
c.ChildIndicatorPolicy = 2
|
|
if self.obj:
|
|
if not hasattr(self.obj,a):
|
|
c.setHidden(True)
|
|
else:
|
|
c.setHidden(True)
|
|
if self.obj:
|
|
for attrib in self.attribs:
|
|
if hasattr(self.obj,attrib):
|
|
Oattrib = getattr(self.obj,attrib)
|
|
Tattrib = getattr(self,"tree"+attrib)
|
|
if Oattrib:
|
|
if attrib == "Base":
|
|
Oattrib = [Oattrib]
|
|
for o in Oattrib:
|
|
item = QtGui.QTreeWidgetItem()
|
|
item.setText(0,o.Name)
|
|
item.setIcon(0,self.getIcon(o))
|
|
Tattrib.addChild(item)
|
|
self.tree.expandItem(Tattrib)
|
|
self.retranslateUi(self.form)
|
|
|
|
def addElement(self):
|
|
it = self.tree.currentItem()
|
|
if it:
|
|
mod = None
|
|
for a in self.attribs:
|
|
if it.text(0) == getattr(self,"tree"+a).text(0):
|
|
mod = a
|
|
for o in FreeCADGui.Selection.getSelection():
|
|
addToComponent(self.obj,o,mod)
|
|
self.update()
|
|
|
|
def removeElement(self):
|
|
it = self.tree.currentItem()
|
|
if it:
|
|
comp = FreeCAD.ActiveDocument.getObject(str(it.text(0)))
|
|
removeFromComponent(self.obj,comp)
|
|
self.update()
|
|
|
|
def accept(self):
|
|
FreeCAD.ActiveDocument.recompute()
|
|
FreeCADGui.ActiveDocument.resetEdit()
|
|
return True
|
|
|
|
def editObject(self,wid,col):
|
|
if wid.parent():
|
|
obj = FreeCAD.ActiveDocument.getObject(str(wid.text(0)))
|
|
if obj:
|
|
self.obj.ViewObject.Transparency = 80
|
|
self.obj.ViewObject.Selectable = False
|
|
obj.ViewObject.show()
|
|
self.accept()
|
|
if obj.isDerivedFrom("Sketcher::SketchObject"):
|
|
FreeCADGui.activateWorkbench("SketcherWorkbench")
|
|
FreeCAD.ArchObserver = ArchSelectionObserver(self.obj,obj)
|
|
FreeCADGui.Selection.addObserver(FreeCAD.ArchObserver)
|
|
FreeCADGui.ActiveDocument.setEdit(obj.Name,0)
|
|
|
|
def retranslateUi(self, TaskPanel):
|
|
TaskPanel.setWindowTitle(QtGui.QApplication.translate("Arch", "Components", None, QtGui.QApplication.UnicodeUTF8))
|
|
self.delButton.setText(QtGui.QApplication.translate("Arch", "Remove", None, QtGui.QApplication.UnicodeUTF8))
|
|
self.addButton.setText(QtGui.QApplication.translate("Arch", "Add", None, QtGui.QApplication.UnicodeUTF8))
|
|
self.title.setText(QtGui.QApplication.translate("Arch", "Components of this object", None, QtGui.QApplication.UnicodeUTF8))
|
|
self.treeBase.setText(0,QtGui.QApplication.translate("Arch", "Base component", None, QtGui.QApplication.UnicodeUTF8))
|
|
self.treeAdditions.setText(0,QtGui.QApplication.translate("Arch", "Additions", None, QtGui.QApplication.UnicodeUTF8))
|
|
self.treeSubtractions.setText(0,QtGui.QApplication.translate("Arch", "Subtractions", None, QtGui.QApplication.UnicodeUTF8))
|
|
self.treeObjects.setText(0,QtGui.QApplication.translate("Arch", "Objects", None, QtGui.QApplication.UnicodeUTF8))
|
|
self.treeAxes.setText(0,QtGui.QApplication.translate("Arch", "Axes", None, QtGui.QApplication.UnicodeUTF8))
|
|
self.treeComponents.setText(0,QtGui.QApplication.translate("Arch", "Components", None, QtGui.QApplication.UnicodeUTF8))
|
|
self.treeFixtures.setText(0,QtGui.QApplication.translate("Arch", "Fixtures", None, QtGui.QApplication.UnicodeUTF8))
|
|
self.treeArmatures.setText(0,QtGui.QApplication.translate("Arch", "Armatures", None, QtGui.QApplication.UnicodeUTF8))
|
|
|
|
class Component:
|
|
"The default Arch Component object"
|
|
def __init__(self,obj):
|
|
obj.addProperty("App::PropertyLink","Base","Arch",translate("Arch","The base object this component is built upon"))
|
|
obj.addProperty("App::PropertyLink","CloneOf","Arch",translate("Arch","The object this component is cloning"))
|
|
obj.addProperty("App::PropertyLinkList","Additions","Arch",translate("Arch","Other shapes that are appended to this object"))
|
|
obj.addProperty("App::PropertyLinkList","Subtractions","Arch",translate("Arch","Other shapes that are subtracted from this object"))
|
|
obj.addProperty("App::PropertyString","Description","Arch",translate("Arch","An optional description for this component"))
|
|
obj.addProperty("App::PropertyString","Tag","Arch",translate("Arch","An optional tag for this component"))
|
|
obj.addProperty("App::PropertyMap","IfcAttributes","Arch",translate("Arch","Custom IFC properties and attributes"))
|
|
obj.addProperty("App::PropertyLink","BaseMaterial","Material",translate("Arch","A material for this object"))
|
|
obj.addProperty("App::PropertyEnumeration","Role","Arch",translate("Arch","The role of this object"))
|
|
obj.addProperty("App::PropertyBool","MoveWithHost","Arch",translate("Arch","Specifies if this object must move together when its host is moved"))
|
|
obj.Proxy = self
|
|
self.Type = "Component"
|
|
self.Subvolume = None
|
|
self.MoveWithHost = False
|
|
obj.Role = Roles
|
|
|
|
def execute(self,obj):
|
|
if obj.Base:
|
|
obj.Shape = obj.Base.Shape
|
|
|
|
def __getstate__(self):
|
|
return self.Type
|
|
|
|
def __setstate__(self,state):
|
|
if state:
|
|
self.Type = state
|
|
|
|
def onChanged(self,obj,prop):
|
|
pass
|
|
|
|
def clone(self,obj):
|
|
"if this object is a clone, sets the shape. Returns True if this is the case"
|
|
if hasattr(obj,"CloneOf"):
|
|
if obj.CloneOf:
|
|
if Draft.getType(obj.CloneOf) == Draft.getType(obj):
|
|
pl = obj.Placement
|
|
obj.Shape = obj.CloneOf.Shape.copy()
|
|
obj.Placement = pl
|
|
if hasattr(obj,"BaseMaterial"):
|
|
if hasattr(obj.CloneOf,"BaseMaterial"):
|
|
obj.BaseMaterial = obj.CloneOf.BaseMaterial
|
|
return True
|
|
return False
|
|
|
|
def getSiblings(self,obj):
|
|
"returns a list of objects with the same type and same base as this object"
|
|
if not hasattr(obj,"Base"):
|
|
return []
|
|
if not obj.Base:
|
|
return []
|
|
siblings = []
|
|
for o in obj.Base.InList:
|
|
if hasattr(o,"Base"):
|
|
if o.Base:
|
|
if o.Base.Name == obj.Base.Name:
|
|
if o.Name != obj.Name:
|
|
if Draft.getType(o) == Draft.getType(obj):
|
|
siblings.append(o)
|
|
return siblings
|
|
|
|
def getAxis(self,obj):
|
|
"Returns an open wire which is the axis of this component, if applicable"
|
|
if obj.Base:
|
|
if obj.Base.isDerivedFrom("Part::Feature"):
|
|
if obj.Base.Shape:
|
|
if (len(obj.Base.Shape.Wires) == 1) and not(obj.Base.Shape.Faces):
|
|
if not obj.Base.Shape.Wires[0].isClosed():
|
|
return obj.Base.Shape.copy()
|
|
elif not(obj.Base.Shape.Solids):
|
|
if hasattr(obj.Base.Shape,"CenterOfMass"):
|
|
p1 = obj.Base.Shape.CenterOfMass
|
|
v = self.getExtrusionVector(obj)
|
|
if v:
|
|
p2 = p1.add(v)
|
|
import Part
|
|
return Part.Line(p1,p2).toShape()
|
|
else:
|
|
p1 = FreeCAD.Vector()
|
|
v = self.getExtrusionVector(obj)
|
|
if v:
|
|
p2 = p1.add(v)
|
|
import Part
|
|
return Part.Line(p1,p2).toShape()
|
|
return None
|
|
|
|
def getProfiles(self,obj,noplacement=False):
|
|
"Returns the base profile(s) of this component, if applicable"
|
|
wires = []
|
|
n,l,w,h = self.getDefaultValues(obj)
|
|
if obj.Base:
|
|
if obj.Base.isDerivedFrom("Part::Extrusion"):
|
|
if obj.Base.Base:
|
|
base = obj.Base.Base.Shape.copy()
|
|
if noplacement:
|
|
base.Placement = FreeCAD.Placement()
|
|
return [base]
|
|
elif obj.Base.isDerivedFrom("Part::Feature"):
|
|
if obj.Base.Shape:
|
|
base = obj.Base.Shape.copy()
|
|
if noplacement:
|
|
base.Placement = FreeCAD.Placement()
|
|
if not base.Solids:
|
|
if base.Faces:
|
|
import DraftGeomUtils
|
|
if not DraftGeomUtils.isCoplanar(base.Faces):
|
|
return []
|
|
return [base]
|
|
|
|
basewires = []
|
|
if not base.Wires:
|
|
if len(base.Edges) == 1:
|
|
import Part
|
|
basewires = [Part.Wire(base.Edges)]
|
|
else:
|
|
basewires = base.Wires
|
|
if basewires:
|
|
import DraftGeomUtils,DraftVecUtils,Part
|
|
for wire in basewires:
|
|
e = wire.Edges[0]
|
|
if isinstance(e.Curve,Part.Circle):
|
|
dvec = e.Vertexes[0].Point.sub(e.Curve.Center)
|
|
else:
|
|
dvec = DraftGeomUtils.vec(wire.Edges[0]).cross(n)
|
|
if not DraftVecUtils.isNull(dvec):
|
|
dvec.normalize()
|
|
sh = None
|
|
if hasattr(obj,"Align"):
|
|
if obj.Align == "Left":
|
|
dvec.multiply(w)
|
|
if hasattr(obj,"Offset"):
|
|
if obj.Offset.Value:
|
|
dvec2 = DraftVecUtils.scaleTo(dvec,obj.Offset.Value)
|
|
wire = DraftGeomUtils.offsetWire(wire,dvec2)
|
|
w2 = DraftGeomUtils.offsetWire(wire,dvec)
|
|
w1 = Part.Wire(DraftGeomUtils.sortEdges(wire.Edges))
|
|
sh = DraftGeomUtils.bind(w1,w2)
|
|
elif obj.Align == "Right":
|
|
dvec.multiply(w)
|
|
dvec = dvec.negative()
|
|
if hasattr(obj,"Offset"):
|
|
if obj.Offset.Value:
|
|
dvec2 = DraftVecUtils.scaleTo(dvec,obj.Offset.Value)
|
|
wire = DraftGeomUtils.offsetWire(wire,dvec2)
|
|
w2 = DraftGeomUtils.offsetWire(wire,dvec)
|
|
w1 = Part.Wire(DraftGeomUtils.sortEdges(wire.Edges))
|
|
sh = DraftGeomUtils.bind(w1,w2)
|
|
elif obj.Align == "Center":
|
|
dvec.multiply(w/2)
|
|
w1 = DraftGeomUtils.offsetWire(wire,dvec)
|
|
dvec = dvec.negative()
|
|
w2 = DraftGeomUtils.offsetWire(wire,dvec)
|
|
sh = DraftGeomUtils.bind(w1,w2)
|
|
if sh:
|
|
wires.append(sh)
|
|
else:
|
|
wires.append(wire)
|
|
elif Draft.getType(obj) in ["Wall","Structure"]:
|
|
if (Draft.getType(obj) == "Structure") and (l > h):
|
|
if noplacement:
|
|
h2 = h/2 or 0.5
|
|
w2 = w/2 or 0.5
|
|
v1 = Vector(-h2,-w2,0)
|
|
v2 = Vector(h2,-w2,0)
|
|
v3 = Vector(h2,w2,0)
|
|
v4 = Vector(-h2,w2,0)
|
|
else:
|
|
h2 = h/2 or 0.5
|
|
w2 = w/2 or 0.5
|
|
v1 = Vector(0,-w2,-h2)
|
|
v2 = Vector(0,-w2,h2)
|
|
v3 = Vector(0,w2,h2)
|
|
v4 = Vector(0,w2,-h2)
|
|
else:
|
|
l2 = l/2 or 0.5
|
|
w2 = w/2 or 0.5
|
|
v1 = Vector(-l2,-w2,0)
|
|
v2 = Vector(l2,-w2,0)
|
|
v3 = Vector(l2,w2,0)
|
|
v4 = Vector(-l2,w2,0)
|
|
import Part
|
|
base = Part.makePolygon([v1,v2,v3,v4,v1])
|
|
return [base]
|
|
return wires
|
|
|
|
def getExtrusionVector(self,obj,noplacement=False):
|
|
"Returns an extrusion vector of this component, if applicable"
|
|
n,l,w,h = self.getDefaultValues(obj)
|
|
if obj.Base:
|
|
if obj.Base.isDerivedFrom("Part::Extrusion"):
|
|
return obj.Base.Dir
|
|
if Draft.getType(obj) == "Structure":
|
|
if l > h:
|
|
v = n.multiply(l)
|
|
if noplacement:
|
|
import DraftVecUtils
|
|
v = DraftVecUtils.rounded(FreeCAD.Rotation(FreeCAD.Vector(0,1,0),-90).multVec(v))
|
|
return v
|
|
return n.multiply(h)
|
|
|
|
def getDefaultValues(self,obj):
|
|
"returns normal,length,width,height values from this component"
|
|
length = 0
|
|
if hasattr(obj,"Length"):
|
|
if obj.Length.Value:
|
|
length = obj.Length.Value
|
|
width = 0
|
|
if hasattr(obj,"Width"):
|
|
if obj.Width.Value:
|
|
width = obj.Width.Value
|
|
height = 0
|
|
if hasattr(obj,"Height"):
|
|
if obj.Height.Value:
|
|
height = obj.Height.Value
|
|
else:
|
|
for p in obj.InList:
|
|
if Draft.getType(p) == "Floor":
|
|
if p.Height.Value:
|
|
height = p.Height.Value
|
|
default = Vector(0,0,1)
|
|
if Draft.getType(obj) == "Structure":
|
|
if length > height:
|
|
default = Vector(1,0,0)
|
|
if hasattr(obj,"Normal"):
|
|
if obj.Normal == Vector(0,0,0):
|
|
normal = default
|
|
else:
|
|
normal = Vector(obj.Normal)
|
|
else:
|
|
normal = default
|
|
return normal,length,width,height
|
|
|
|
def getPlacement(self,obj):
|
|
"returns a total placement for the profile of this component"
|
|
p = FreeCAD.Placement()
|
|
if obj.Base:
|
|
p = obj.Base.Placement.multiply(p)
|
|
else:
|
|
if Draft.getType(obj) == "Structure":
|
|
n,l,w,h = self.getDefaultValues(obj)
|
|
if l > h:
|
|
p.Rotation = FreeCAD.Rotation(FreeCAD.Vector(0,1,0),90)
|
|
p = obj.Placement.multiply(p)
|
|
return p
|
|
|
|
def hideSubobjects(self,obj,prop):
|
|
"Hides subobjects when a subobject lists change"
|
|
if prop in ["Additions","Subtractions"]:
|
|
if hasattr(obj,prop):
|
|
for o in getattr(obj,prop):
|
|
if (Draft.getType(o) != "Window") and (not Draft.isClone(o,"Window",True)):
|
|
if (Draft.getType(obj) == "Wall"):
|
|
if (Draft.getType(o) == "Roof"):
|
|
continue
|
|
o.ViewObject.hide()
|
|
|
|
def processSubShapes(self,obj,base,placement=None):
|
|
"Adds additions and subtractions to a base shape"
|
|
import Draft,Part
|
|
#print "Processing subshapes of ",obj.Label, " : ",obj.Additions
|
|
|
|
if placement:
|
|
if placement.isNull():
|
|
placement = None
|
|
else:
|
|
placement = FreeCAD.Placement(placement)
|
|
placement = placement.inverse()
|
|
|
|
# treat additions
|
|
for o in obj.Additions:
|
|
|
|
if not base:
|
|
if o.isDerivedFrom("Part::Feature"):
|
|
base = o.Shape
|
|
else:
|
|
if base.isNull():
|
|
if o.isDerivedFrom("Part::Feature"):
|
|
base = o.Shape
|
|
else:
|
|
# special case, both walls with coinciding endpoints
|
|
import ArchWall
|
|
js = ArchWall.mergeShapes(o,obj)
|
|
if js:
|
|
add = js.cut(base)
|
|
if placement:
|
|
add.Placement = add.Placement.multiply(placement)
|
|
base = base.fuse(add)
|
|
|
|
elif (Draft.getType(o) == "Window") or (Draft.isClone(o,"Window",True)):
|
|
f = o.Proxy.getSubVolume(o)
|
|
if f:
|
|
if base.Solids and f.Solids:
|
|
if placement:
|
|
f.Placement = f.Placement.multiply(placement)
|
|
base = base.cut(f)
|
|
|
|
elif o.isDerivedFrom("Part::Feature"):
|
|
if o.Shape:
|
|
if not o.Shape.isNull():
|
|
if o.Shape.Solids:
|
|
s = o.Shape.copy()
|
|
if placement:
|
|
s.Placement = s.Placement.multiply(placement)
|
|
if base:
|
|
if base.Solids:
|
|
try:
|
|
base = base.fuse(s)
|
|
except Part.OCCError:
|
|
print "Arch: unable to fuse object ",obj.Name, " with ", o.Name
|
|
else:
|
|
base = s
|
|
|
|
# treat subtractions
|
|
for o in obj.Subtractions:
|
|
|
|
if base:
|
|
if base.isNull():
|
|
base = None
|
|
|
|
if base:
|
|
if (Draft.getType(o) == "Window") or (Draft.isClone(o,"Window",True)):
|
|
# windows can be additions or subtractions, treated the same way
|
|
f = o.Proxy.getSubVolume(o)
|
|
if f:
|
|
if base.Solids and f.Solids:
|
|
if placement:
|
|
f.Placement = f.Placement.multiply(placement)
|
|
base = base.cut(f)
|
|
|
|
elif (Draft.getType(o) == "Roof") or (Draft.isClone(o,"Roof")):
|
|
# roofs define their own special subtraction volume
|
|
f = o.Proxy.getSubVolume(o)
|
|
if f:
|
|
if base.Solids and f.Solids:
|
|
base = base.cut(f)
|
|
|
|
elif o.isDerivedFrom("Part::Feature"):
|
|
if o.Shape:
|
|
if not o.Shape.isNull():
|
|
if o.Shape.Solids and base.Solids:
|
|
s = o.Shape.copy()
|
|
if placement:
|
|
s.Placement = s.Placement.multiply(placement)
|
|
try:
|
|
base = base.cut(s)
|
|
except Part.OCCError:
|
|
print "Arch: unable to cut object ",o.Name, " from ", obj.Name
|
|
return base
|
|
|
|
def applyShape(self,obj,shape,placement):
|
|
"checks and cleans the given shape, and apply it to the object"
|
|
if shape:
|
|
if not shape.isNull():
|
|
if shape.isValid():
|
|
if shape.Solids:
|
|
if shape.Volume < 0:
|
|
shape.reverse()
|
|
if shape.Volume < 0:
|
|
FreeCAD.Console.PrintError(translate("Arch","Error computing the shape of this object")+"\n")
|
|
return
|
|
shape = shape.removeSplitter()
|
|
obj.Shape = shape
|
|
if not placement.isNull():
|
|
obj.Placement = placement
|
|
else:
|
|
FreeCAD.Console.PrintWarning(obj.Label + " " + translate("Arch","has no solid")+"\n")
|
|
else:
|
|
FreeCAD.Console.PrintWarning(obj.Label + " " + translate("Arch","has an invalid shape")+"\n")
|
|
else:
|
|
FreeCAD.Console.PrintWarning(obj.Label + " " + translate("Arch","has a null shape")+"\n")
|
|
|
|
|
|
class ViewProviderComponent:
|
|
"A default View Provider for Component objects"
|
|
def __init__(self,vobj):
|
|
vobj.Proxy = self
|
|
self.Object = vobj.Object
|
|
|
|
def updateData(self,obj,prop):
|
|
#print obj.Name," : updating ",prop
|
|
if prop == "BaseMaterial":
|
|
if obj.BaseMaterial:
|
|
if 'Color' in obj.BaseMaterial.Material:
|
|
if "(" in obj.BaseMaterial.Material['Color']:
|
|
c = tuple([float(f) for f in obj.BaseMaterial.Material['Color'].strip("()").split(",")])
|
|
if obj.ViewObject:
|
|
obj.ViewObject.ShapeColor = c
|
|
elif prop == "Shape":
|
|
if obj.Base:
|
|
if obj.Base.isDerivedFrom("Part::Compound"):
|
|
if obj.ViewObject.DiffuseColor != obj.Base.ViewObject.DiffuseColor:
|
|
obj.ViewObject.DiffuseColor = obj.Base.ViewObject.DiffuseColor
|
|
obj.ViewObject.update()
|
|
self.onChanged(obj.ViewObject,"ShapeColor")
|
|
elif prop == "CloneOf":
|
|
if obj.CloneOf:
|
|
if obj.ViewObject.DiffuseColor != obj.CloneOf.ViewObject.DiffuseColor:
|
|
obj.ViewObject.DiffuseColor = obj.CloneOf.ViewObject.DiffuseColor
|
|
obj.ViewObject.update()
|
|
self.onChanged(obj.ViewObject,"ShapeColor")
|
|
return
|
|
|
|
def getIcon(self):
|
|
import Arch_rc
|
|
return ":/icons/Arch_Component.svg"
|
|
|
|
def onChanged(self,vobj,prop):
|
|
#print vobj.Object.Name, " : changing ",prop
|
|
if prop == "Visibility":
|
|
for obj in vobj.Object.Additions+vobj.Object.Subtractions:
|
|
if (Draft.getType(obj) == "Window") or (Draft.isClone(obj,"Window",True)):
|
|
obj.ViewObject.Visibility = vobj.Visibility
|
|
elif prop == "DiffuseColor":
|
|
if hasattr(vobj.Object,"CloneOf"):
|
|
if vobj.Object.CloneOf:
|
|
if vobj.DiffuseColor != vobj.Object.CloneOf.ViewObject.DiffuseColor:
|
|
vobj.DiffuseColor = vobj.Object.CloneOf.ViewObject.DiffuseColor
|
|
vobj.update()
|
|
elif prop == "ShapeColor":
|
|
# restore DiffuseColor after overridden by ShapeColor
|
|
if len(vobj.DiffuseColor) > 1:
|
|
d = vobj.DiffuseColor
|
|
vobj.DiffuseColor = d
|
|
return
|
|
|
|
def attach(self,vobj):
|
|
self.Object = vobj.Object
|
|
return
|
|
|
|
def getDisplayModes(self,vobj):
|
|
return []
|
|
|
|
def setDisplayMode(self,mode):
|
|
return mode
|
|
|
|
def __getstate__(self):
|
|
return None
|
|
|
|
def __setstate__(self,state):
|
|
return None
|
|
|
|
def claimChildren(self):
|
|
if hasattr(self,"Object"):
|
|
c = []
|
|
if hasattr(self.Object,"Base"):
|
|
if Draft.getType(self.Object) != "Wall":
|
|
c = [self.Object.Base]
|
|
elif Draft.getType(self.Object.Base) == "Space":
|
|
c = []
|
|
else:
|
|
c = [self.Object.Base]
|
|
if hasattr(self.Object,"Additions"):
|
|
c.extend(self.Object.Additions)
|
|
if hasattr(self.Object,"Subtractions"):
|
|
for s in self.Object.Subtractions:
|
|
if Draft.getType(self.Object) == "Wall":
|
|
if Draft.getType(s) == "Roof":
|
|
continue
|
|
c.append(s)
|
|
if hasattr(self.Object,"Armatures"):
|
|
c.extend(self.Object.Armatures)
|
|
if hasattr(self.Object,"Group"):
|
|
c.extend(self.Object.Group)
|
|
if hasattr(self.Object,"Tool"):
|
|
if self.Object.Tool:
|
|
c.append(self.Object.Tool)
|
|
return c
|
|
return []
|
|
|
|
def setEdit(self,vobj,mode):
|
|
taskd = ComponentTaskPanel()
|
|
taskd.obj = self.Object
|
|
taskd.update()
|
|
FreeCADGui.Control.showDialog(taskd)
|
|
return True
|
|
|
|
def unsetEdit(self,vobj,mode):
|
|
FreeCADGui.Control.closeDialog()
|
|
return False
|
|
|
|
|
|
class ArchSelectionObserver:
|
|
"""ArchSelectionObserver([origin,watched,hide,nextCommand]): The ArchSelectionObserver
|
|
object can be added as a selection observer to the FreeCAD Gui. If watched is given (a
|
|
document object), the observer will be triggered only when that object is selected/unselected.
|
|
If hide is True, the watched object will be hidden. If origin is given (a document
|
|
object), that object will have its visibility/selectability restored. If nextCommand
|
|
is given (a FreeCAD command), it will be executed on leave."""
|
|
|
|
def __init__(self,origin=None,watched=None,hide=True,nextCommand=None):
|
|
self.origin = origin
|
|
self.watched = watched
|
|
self.hide = hide
|
|
self.nextCommand = nextCommand
|
|
|
|
def addSelection(self,document, object, element, position):
|
|
if not self.watched:
|
|
FreeCADGui.Selection.removeObserver(FreeCAD.ArchObserver)
|
|
if self.nextCommand:
|
|
FreeCADGui.runCommand(self.nextCommand)
|
|
del FreeCAD.ArchObserver
|
|
elif object == self.watched.Name:
|
|
if not element:
|
|
FreeCAD.Console.PrintMessage(translate("Arch","closing Sketch edit"))
|
|
if self.hide:
|
|
if self.origin:
|
|
self.origin.ViewObject.Transparency = 0
|
|
self.origin.ViewObject.Selectable = True
|
|
self.watched.ViewObject.hide()
|
|
FreeCADGui.activateWorkbench("ArchWorkbench")
|
|
if hasattr(FreeCAD,"ArchObserver"):
|
|
FreeCADGui.Selection.removeObserver(FreeCAD.ArchObserver)
|
|
del FreeCAD.ArchObserver
|
|
if self.nextCommand:
|
|
FreeCADGui.Selection.clearSelection()
|
|
FreeCADGui.Selection.addSelection(self.watched)
|
|
FreeCADGui.runCommand(self.nextCommand)
|