def requires_newer_freecad(self) -> Optional[str]:
"""If the current package is not installed, returns the first supported version of
FreeCAD, if one is set, or None if no information is available (or if the package is
already installed)."""
# If it's not installed, check to see if it's for a newer version of FreeCAD
if self.repo.status(
) == Addon.Status.NOT_INSTALLED and self.repo.metadata:
# Only hide if ALL content items require a newer version, otherwise
# it's possible that this package actually provides versions of itself
# for newer and older versions
first_supported_version = (
self.repo.metadata.getFirstSupportedFreeCADVersion())
if first_supported_version is not None:
required_version = first_supported_version.split(".")
fc_major = int(FreeCAD.Version()[0])
fc_minor = int(FreeCAD.Version()[1])
if int(required_version[0]) > fc_major:
return first_supported_version
if int(required_version[0]
) == fc_major and len(required_version) > 1:
if int(required_version[1]) > fc_minor:
return first_supported_version
return None
def _process_deprecated(self, deprecated_addons):
"""Parse the section on deprecated addons"""
fc_major = int(FreeCAD.Version()[0])
fc_minor = int(FreeCAD.Version()[1])
for item in deprecated_addons:
if "as_of" in item and "name" in item:
try:
version_components = item["as_of"].split(".")
major = int(version_components[0])
if len(version_components) > 1:
minor = int(version_components[1])
else:
minor = 0
if major < fc_major or (major == fc_major and minor <= fc_minor):
if "kind" not in item or item["kind"] == "mod":
self.obsolete.append(item["name"])
elif item["kind"] == "macro":
self.macros_reject_list.append(item["name"])
else:
FreeCAD.Console.PrintMessage(
f'Unrecognized Addon kind {item["kind"]} in deprecation list.'
)
except ValueError:
FreeCAD.Console.PrintMessage(
f"Failed to parse version from {item['name']}, version {item['as_of']}"
)
def checkRequirements(cq):
#checking requirements
FreeCAD.Console.PrintMessage("FC Version \r\n")
FreeCAD.Console.PrintMessage(FreeCAD.Version())
FC_majorV = FreeCAD.Version()[0]
FC_minorV = FreeCAD.Version()[1]
FreeCAD.Console.PrintMessage('FC Version ' + FC_majorV + FC_minorV +
'\r\n')
if int(FC_majorV) <= 0:
if int(FC_minorV) < 15:
reply = QtGui.QMessageBox.information(
None, "Warning! ...", "use FreeCAD version >= " + FC_majorV +
"." + FC_minorV + "\r\n")
#check version
cqv = cq.__version__.split(".")
#say2(cqv)
if int(cqv[0]) == 0 and int(cqv[1]) < 3:
msg = "CadQuery Module needs to be at least 0.3.0!\r\n\r\n"
reply = QtGui.QMessageBox.information(None, "Info ...", msg)
say("cq needs to be at least 0.3.0")
stop
if float(cq.__version__[:-2]) < 0.3:
msg = "missing CadQuery 0.3.0 or later Module!\r\n\r\n"
msg += "https://github.com/jmwright/cadquery-freecad-module/wiki\n"
msg += "actual CQ version " + cq.__version__
reply = QtGui.QMessageBox.information(None, "Info ...", msg)
return 0
def Activated(self):
FreeCAD.Console.PrintWarning('opening ' + self.exFile + "\r\n")
import os, sys
# So we can open the "Open File" dialog
mw = FreeCADGui.getMainWindow()
# Start off defaulting to the Examples directory
manp_base_path = mvr_locator.module_path()
exs_dir_path = os.path.join(manp_base_path, 'help')
abs_manp_path = mvr_locator.abs_module_path()
# Append this script's directory to sys.path
sys.path.append(os.path.dirname(exs_dir_path))
fnameDemo=(os.path.join(exs_dir_path, self.exFile))
ext = os.path.splitext(os.path.basename(fnameDemo))[1]
nme = os.path.splitext(os.path.basename(fnameDemo))[0] # We've created a library that FreeCAD can use as well to open CQ files
FC_majorV=int(float(FreeCAD.Version()[0]))
FC_minorV=int(float(FreeCAD.Version()[1]))
if ext.lower()==".pdf":
import subprocess, sys
if sys.platform == "linux" or sys.platform == "linux2":
# linux
subprocess.call(["xdg-open", fnameDemo])
if sys.platform == "darwin":
# osx
cmd_open = 'open '+fnameDemo
os.system(cmd_open) #win, osx
else:
# win
subprocess.Popen([fnameDemo],shell=True)
def version_is_ok(self, metadata) -> bool:
dep_fc_min = metadata.FreeCADMin
dep_fc_max = metadata.FreeCADMax
fc_major = int(FreeCAD.Version()[0])
fc_minor = int(FreeCAD.Version()[1])
try:
if dep_fc_min and dep_fc_min != "0.0.0":
required_version = dep_fc_min.split(".")
if fc_major < int(required_version[0]):
return False # Major version is too low
elif fc_major == int(required_version[0]):
if len(required_version) > 1 and fc_minor < int(required_version[1]):
return False # Same major, and minor is too low
except ValueError:
FreeCAD.Console.PrintMessage(f"Metadata file for {self.name} has invalid FreeCADMin version info\n")
try:
if dep_fc_max and dep_fc_max != "0.0.0":
required_version = dep_fc_max.split(".")
if fc_major > int(required_version[0]):
return False # Major version is too high
elif fc_major == int(required_version[0]):
if len(required_version) > 1 and fc_minor > int(required_version[1]):
return False # Same major, and minor is too high
except ValueError:
FreeCAD.Console.PrintMessage(f"Metadata file for {self.name} has invalid FreeCADMax version info\n")
return True
def IsActive(self):
if FreeCAD.ActiveDocument:
# disable for pre-v0.18
if float(FreeCAD.Version()[0] + "." + FreeCAD.Version()[1]) < 0.18:
return False
return True
else:
return False
def onPreStart():
"""Start in FreeCAD 0.18 or above."""
version = App.Version()[0] + "." + App.Version()[1]
if version >= "0.18":
if mw.property("eventLoop"):
onStart()
else:
t.stop()
t.deleteLater()
def put_it_in(self, dummy):
self.title = "third_angle_projection_symbol"
thick = 0.7 # The wider of the two line widths suggested in\
# BS 8888:2011
thin = 0.35 # The narrower of the two line widths suggested\
# in BS 8888:2011
# BS 8888:2011 does not specify the exact dimensions
# of the truncated cone, axonometric projections of
# which form the symbol, so those dimensions are taken
# from user input.
base_radius = 0.5 * self.h
top_radius = 0.5 * self.H
self.spacing = 3.0 * self.d
depth = self.H
height = self.H
width = self.H
top_centre = FreeCAD.Vector(top_radius, 0.0, top_radius)
depth_wise_direction = FreeCAD.Vector(0.0, 1.0, 0.0)
part = Part.makeCone(base_radius, top_radius, self.H, top_centre,
depth_wise_direction)
dummydoc = FreeCAD.newDocument("Dummy")
part_in_tree = dummydoc.addObject("Part::Feature", self.title)
part_in_tree.Shape = part
featurepart = dummydoc.getObject(self.title)
versionnumber = float(FreeCAD.Version()[0])\
+0.01*float(FreeCAD.Version()[1])
self.scale = 1.0
plusxview = self.addsingleview(versionnumber, " from positive x",
featurepart,
FreeCAD.Vector(1.0, 0.0, 0.0), width,
depth, height, 1.0, 0.0, 1.0, 0.0, 0.0,
0.0, 0.5, 1.0, 1.0, 0.0, 0.0, 270.0,
0.0, thick, thin)
minusyview = self.addsingleview(versionnumber, " from negative y",
featurepart,
FreeCAD.Vector(0.0, -1.0, 0.0), width,
depth, height, 0.0, 0.0, 0.0, 0.0, 0.0,
0.0, 0.0, 0.5, 0.0, 0.0, 0.0, 90.0,
0.0, thick, thin)
self.drawing_page.Document.recompute()
# Leaving the dummy document open is a waste of RAM
# and clutters up the GUI, so ideally, one would like
# to close it. Unfortunately, attempting to close the
# dummy document causes a segfault, at least under
# FreeCAD 0.16 on Scientific Linux 7.3 and FreeCAD
# 0.16 on Fedora 28, so the following command operates
# only if the FreeCAD version is 0.18.4 or later.
# (I've checked, and the segfault doesn't happen under
# FreeCAD 0.18.4 on Ubuntu 20.04.)
if (versionnumber >= 0.184):
FreeCAD.closeDocument("Dummy")
def getFCversion():
FC_majorV = int(float(FreeCAD.Version()[0]))
FC_minorV = int(float(FreeCAD.Version()[1]))
try:
FC_git_Nbr = int(
float(FreeCAD.Version()[2].strip(" (Git)").split(' ')[0])
) #+int(FreeCAD.Version()[2].strip(" (Git)").split(' ')[1])
except:
FC_git_Nbr = 0
return FC_majorV, FC_minorV, FC_git_Nbr
def checkFC_Version(self):
import FreeCAD
from PySide import QtGui
# FC requirement constants
FC_MINOR_VER_REQUIRED = 17
FC_COMMIT_REQUIRED = 13528
FC_MINOR_VER_RECOMMENDED = 18
FC_COMMIT_RECOMMENDED = 15997
ver = FreeCAD.Version()
gitver = ver[2].split()[0]
if gitver != 'Unknown':
gitver = int(gitver)
else:
gitver = FC_COMMIT_REQUIRED
if (
(int(ver[0]) == 0 and int(ver[1]) < FC_MINOR_VER_REQUIRED) or
(int(ver[0]) == 0 and gitver < FC_COMMIT_REQUIRED)
):
fc_msg = '''
FreeCAD version ({}.{}.{}) must be at
least {}.{}.{} to be used with the
A2P workbench\n\n'''.format(
int(ver[0]),
int(ver[1]),
gitver,
0,
FC_MINOR_VER_REQUIRED,
FC_COMMIT_REQUIRED
)
print(fc_msg)
diag = QtGui.QMessageBox(QtGui.QMessageBox.Critical,u"Error Message",fc_msg )
diag.exec_()
elif (
int(ver[0]) == 0 and
(int(ver[1]) < FC_MINOR_VER_RECOMMENDED or
(int(ver[1]) == FC_MINOR_VER_RECOMMENDED and gitver < FC_COMMIT_RECOMMENDED)
)
):
fc_msg = '''
While FreeCAD version ({}.{}.{}) will
work with the A2P workbench, it is recommended
to use {}.{}.{} or above.\n\n'''.format(
int(ver[0]),
int(ver[1]),
gitver,
0,
FC_MINOR_VER_RECOMMENDED,
FC_COMMIT_RECOMMENDED
)
print(fc_msg)
# do not display an additional dialog in this case.
# Console output is enough
else:
# FC version is ok. No Message needed.
pass
def __init__(self, analysis_obj, solver_obj, mesh_obj, matlin_obj,
matnonlin_obj, fixed_obj, displacement_obj, contact_obj,
planerotation_obj, transform_obj, selfweight_obj, force_obj,
pressure_obj, temperature_obj, heatflux_obj,
initialtemperature_obj, beamsection_obj, beamrotation_obj,
shellthickness_obj, fluidsection_obj, dir_name):
self.analysis = analysis_obj
self.solver_obj = solver_obj
self.analysis_type = self.solver_obj.AnalysisType
self.mesh_object = mesh_obj
self.material_objects = matlin_obj
self.material_nonlinear_objects = matnonlin_obj
self.fixed_objects = fixed_obj
self.displacement_objects = displacement_obj
self.contact_objects = contact_obj
self.planerotation_objects = planerotation_obj
self.transform_objects = transform_obj
self.selfweight_objects = selfweight_obj
self.force_objects = force_obj
self.pressure_objects = pressure_obj
self.temperature_objects = temperature_obj
self.heatflux_objects = heatflux_obj
self.initialtemperature_objects = initialtemperature_obj
self.beamsection_objects = beamsection_obj
self.beamrotation_objects = beamrotation_obj
self.fluidsection_objects = fluidsection_obj
self.shellthickness_objects = shellthickness_obj
self.dir_name = dir_name
if not dir_name:
FreeCAD.Console.PrintError(
'Error: FemInputWriter has no working_dir --> we are going to make a temporary one!\n'
)
self.dir_name = FreeCAD.ActiveDocument.TransientDir.replace(
'\\', '/') + '/FemAnl_' + analysis_obj.Uid[-4:]
self.dir_name = os.path.join(
self.dir_name,
'') # check dir_name has a slash at the end, if not add one
if not os.path.isdir(self.dir_name):
os.mkdir(self.dir_name)
self.fc_ver = FreeCAD.Version()
self.ccx_nall = 'Nall'
self.ccx_eall = 'Eall'
self.ccx_evolumes = 'Evolumes'
self.ccx_efaces = 'Efaces'
self.ccx_eedges = 'Eedges'
self.ccx_elsets = []
if hasattr(self.mesh_object, "Shape"):
self.theshape = self.mesh_object.Shape
elif hasattr(self.mesh_object, "Part"):
self.theshape = self.mesh_object.Part
self.femmesh = self.mesh_object.FemMesh
self.femnodes_mesh = {}
self.femelement_table = {}
self.constraint_conflict_nodes = []
self.femnodes_ele_table = {}
self.femelements_edges_only = []
self.femelements_faces_only = []
self.femelement_volumes_table = {}
self.femelement_faces_table = {}
self.femelement_edges_table = {}
def new_axes(self):
if int(FreeCAD.Version()[1]) >= 19.:
# logger.warning('FreeCAD 19 or newer')
obj = self.Object.obj_list[self.Object.obj_combo.currentIndex()]
axis_d = FreeCAD.Vector(self.d_x.value(), self.d_y.value(),
self.d_z.value())
axis_w = FreeCAD.Vector(self.w_x.value(), self.w_y.value(),
self.w_z.value())
axis_h = FreeCAD.Vector(self.h_x.value(), self.h_y.value(),
self.h_z.value())
if 'axis_d' in obj.PropertiesList:
obj.axis_d = axis_d
else:
obj.addProperty("App::PropertyVector", "axis_d", obj.Name,
"Internal axis d", 4).axis_d = axis_d
if 'axis_w' in obj.PropertiesList:
obj.axis_w = axis_w
else:
obj.addProperty("App::PropertyVector", "axis_w", obj.Name,
"Internal axis w", 4).axis_w = axis_w
if 'axis_h' in obj.PropertiesList:
obj.axis_h = axis_h
else:
obj.addProperty("App::PropertyVector", "axis_h", obj.Name,
"Internal axis h", 4).axis_h = axis_h
else:
logger.warning(
'FreeCAD version need to be 19 or newer to use this utility')
def onPreStart():
""""""
if App.Version()[1] < "17":
onStart()
else:
if mw.property("eventLoop"):
onStart()
def setup(self, sync=None):
if float(".".join(FreeCAD.Version()[0:2])) == 0.18:
#part of the FC 0.18 no proxy change event workaround
if hasattr(self.obj, 'Proxy'):
self.proxydata = self.obj.Proxy
#collect all property values and infos
infos = []
for prop in self.obj.PropertiesList:
info = Property.createInformation(self.obj, prop)
infos.append(info)
#check if we need to handle a syncronisation
if sync:
self._runner.sync(sync)
#setup ourself
self._runner.run(self.Writer.setup, self.obj.TypeId,
self.obj.PropertiesList, infos)
#check if there are properties that need the default values uploaded
props = Property.getNonDefaultValueProperties(self.obj)
for prop in props:
self._runner.run(
self.Writer.changeProperty(
prop, Property.convertPropertyToWamp(self.obj, prop), []))
def _create_frame():
"""Draw a frame with information on the version of the software.
It includes the date created, the version, the release type,
and the branch.
"""
version = App.Version()
now = datetime.datetime.now().strftime("%Y/%m/%dT%H:%M:%S")
_text = [
"Part test file", "Created: {}".format(now), "\n",
"Version: " + ".".join(version[0:3]),
"Release: " + " ".join(version[3:5]),
"Branch: " + " ".join(version[5:])
]
record = App.ActiveDocument.addObject("App::Annotation", "Description")
record.LabelText = _text
record.Position = Vector(0, -1000, 0)
if App.GuiUp:
record.ViewObject.DisplayMode = "World"
record.ViewObject.FontSize = 400
record.ViewObject.TextColor = (0.0, 0.0, 0.0)
p1 = Vector(-1000, -3500, 0)
p2 = Vector(20000, -3500, 0)
p3 = Vector(20000, 8500, 0)
p4 = Vector(-1000, 8500, 0)
poly = Part.makePolygon([p1, p2, p3, p4, p1])
frame = App.ActiveDocument.addObject("Part::Feature", "Frame")
frame.Shape = poly
def __init__(self, vobj):
vobj.Proxy = self
if int(FreeCAD.Version()[1]) > 19:
vobj.addExtension("Gui::ViewProviderGroupExtensionPython")
else:
vobj.addExtension("Gui::ViewProviderGroupExtensionPython",
self) #20220704
def __init__(self,
obj,
base,
DN="DN50",
PRating="SCH-STD",
OD=60.3,
thk=3,
BR=None):
# initialize the parent class
super(PypeBranch2, self).__init__(obj)
# define common properties
obj.PType = "PypeBranch"
obj.PSize = DN
obj.PRating = PRating
# define specific properties
if int(FreeCAD.Version()[1]) > 19:
obj.addExtension("App::GroupExtensionPython")
else:
obj.addExtension("App::GroupExtensionPython", obj) #20220704
obj.addProperty("App::PropertyLength", "OD", "PypeBranch",
"Outside diameter").OD = OD
obj.addProperty("App::PropertyLength", "thk", "PypeBranch",
"Wall thickness").thk = thk
if not BR: BR = 0.75 * OD
obj.addProperty("App::PropertyLength", "BendRadius", "PypeBranch",
"Bend Radius").BendRadius = BR
obj.addProperty("App::PropertyStringList", "Tubes", "PypeBranch",
"The tubes of the branch.")
obj.addProperty("App::PropertyStringList", "Curves", "PypeBranch",
"The curves of the branch.")
obj.addProperty("App::PropertyLink", "Base", "PypeBranch", "The path.")
if hasattr(base, "Shape") and base.Shape.Edges:
obj.Base = base
else:
FreeCAD.Console.PrintError('Base not valid\n')
def get_fc_version():
"""returns tuple like (0,18,4,16154) for 0.18.4 release, and (0,19,0,18234) for pre builds"""
# ['0', '18', '4 (GitTag)', 'git://github.com/FreeCAD/FreeCAD.git releases/FreeCAD-0-18', '2019/10/22 16:53:35', 'releases/FreeCAD-0-18', '980bf9060e28555fecd9e3462f68ca74007b70f8']
# ['0', '19', '18234 (Git)', 'git://github.com/FreeCAD/FreeCAD.git master', '2019/09/15 20:43:17', 'master', '3af5d97e9b2a60823815f662aba25422c4bc45bb']
strmaj, strmi, strrev = App.Version()[0:3]
maj, mi = int(strmaj), int(strmi)
submi, rev = 0, 0
if '(GitTag)' in strrev:
submi = int(strrev.split(" ")[0])
elif '(Git)' in strrev:
try:
rev = int(strrev.split(" ")[0])
except Exception as err:
App.Console.PrintWarning(
u"PartOMagic failed to detect FC version number.\n"
" {err}\n".format(err=str(err)))
rev = 19207 #assume fairly modern
if rev < 100:
if mi == 17:
rev = 13544
elif mi == 18:
rev = 16154
else:
rev = 19207 #assume fairly modern
App.Console.PrintWarning(
u"PartOMagic failed to detect FC version number: revision is zero / too low, minor version is unexpected."
)
return (maj, mi, submi, rev)
def setPropertyStatus(obj, prop, status):
with __fcobject_processing(obj):
if float(".".join(FreeCAD.Version()[0:2])) >= 0.19:
if status:
#to set the status multiple things need to happen:
# 1. remove all string status entries we do not support
supported = obj.getPropertyStatus()
filtered = [
s for s in status
if not isinstance(s, str) or s in supported
]
# 2. check which are to be added, and add those
current = obj.getPropertyStatus(prop)
add = [s for s in filtered if not s in current]
obj.setPropertyStatus(prop, add)
# 3. check which are to be removed, and remove those
remove = [s for s in current if not s in filtered]
signed = [-s for s in remove if isinstance(s, int)]
signed += ["-" + s for s in remove if isinstance(s, str)]
obj.setPropertyStatus(prop, signed)
else:
# None status means removing all of them!
remove = obj.getPropertyStatus(prop)
signed = [-s for s in remove if isinstance(s, int)]
signed += ["-" + s for s in remove if isinstance(s, str)]
obj.setPropertyStatus(prop, signed)
else:
obj.setEditorMode(prop, Property.statusToEditorMode(status))
def __init__(self, analysis_obj, solver_obj, mesh_obj, mat_obj, fixed_obj,
selfweight_obj, force_obj, pressure_obj, displacement_obj,
beamsection_obj, shellthickness_obj, analysis_type,
eigenmode_parameters, dir_name):
self.analysis = analysis_obj
self.solver_obj = solver_obj
self.mesh_object = mesh_obj
self.material_objects = mat_obj
self.fixed_objects = fixed_obj
self.selfweight_objects = selfweight_obj
self.force_objects = force_obj
self.pressure_objects = pressure_obj
self.displacement_objects = displacement_obj
self.beamsection_objects = beamsection_obj
self.shellthickness_objects = shellthickness_obj
self.analysis_type = analysis_type
if eigenmode_parameters:
self.no_of_eigenfrequencies = eigenmode_parameters[0]
self.eigenfrequeny_range_low = eigenmode_parameters[1]
self.eigenfrequeny_range_high = eigenmode_parameters[2]
self.dir_name = dir_name
if not dir_name:
print(
'Error: FemInputWriter has no working_dir --> we gone make a temporary one!'
)
self.dir_name = FreeCAD.ActiveDocument.TransientDir.replace(
'\\', '/') + '/FemAnl_' + analysis_obj.Uid[-4:]
if not os.path.isdir(self.dir_name):
os.mkdir(self.dir_name)
self.fc_ver = FreeCAD.Version()
self.ccx_eall = 'Eall'
self.ccx_elsets = []
self.femmesh = self.mesh_object.FemMesh
self.femnodes_mesh = {}
self.femelement_table = {}
def export(exportList, filename):
"called when FreeCAD exports a file"
# process Objects
print("\nStart Export 0.1d\n")
print("Open Output File")
csg = pythonopen(filename, 'w')
print("Write Initial Output")
# Not sure if comments as per scad are allowed in csg file
csg.write("// CSG file generated from FreeCAD %s\n" % \
'.'.join(FreeCAD.Version()[0:3]))
#write initial group statements - not sure if required
csg.write("group() {\n group(){\n")
for ob in exportList:
print(ob)
print("Name : " + ob.Name)
print("Type : " + ob.TypeId)
print("Shape : ")
print(ob.Shape)
process_object(csg, ob)
# write closing group braces
csg.write("}\n}\n")
# close file
csg.close()
FreeCAD.Console.PrintMessage("successfully exported " + filename)
def onPreStart():
"""Improve start reliability and maintain FreeCAD 0.16 support."""
if App.Version()[1] < "17":
onStart()
else:
if mw.property("eventLoop"):
onStart()
def export(exportList, filename):
"called when freecad exports a file"
outfile = pythonopen(filename, "wb")
ver = FreeCAD.Version()
outfile.write("# FreeCAD v" + ver[0] + "." + ver[1] + " build" + ver[2] +
" Arch module\n")
outfile.write("# http://www.freecadweb.org\n")
offset = 1
for obj in exportList:
if obj.isDerivedFrom("Part::Feature"):
if obj.ViewObject.isVisible():
vlist, elist, flist = getIndices(obj.Shape, offset)
if vlist == None:
FreeCAD.Console.PrintError("Unable to export object " +
obj.Label + ". Skipping.\n")
else:
offset += len(vlist)
outfile.write("o " + obj.Name + "\n")
for v in vlist:
outfile.write("v" + v + "\n")
for e in elist:
outfile.write("l" + e + "\n")
for f in flist:
outfile.write("f" + f + "\n")
outfile.close()
FreeCAD.Console.PrintMessage(
translate("Arch", "successfully written ") + filename + "\n")
def make_attachable(self, obj):
# Needed to make this object "attachable",
# aka able to attach parameterically to other objects
# cf. https://wiki.freecadweb.org/Scripted_objects_with_attachment
if int(App.Version()[1]) >= 19:
obj.addExtension('Part::AttachExtensionPython')
else:
obj.addExtension('Part::AttachExtensionPython', obj)
def makePartFrame(part):
obj = FreeCAD.ActiveDocument.addObject("App::FeaturePython", "PartFrame")
PartFrame(obj, part)
if int(FreeCAD.Version()[1]) > 16:
geo_feature_group = part.getParentGeoFeatureGroup()
geo_feature_group.addObject(obj)
if FreeCAD.GuiUp:
ViewProviderPartFrame(obj.ViewObject)
return obj
def FC_version():
try:
import FreeCAD
vertup = FreeCAD.Version()
# ['0', '18', '15518 (Git)', 'git://github.com/FreeCAD/FreeCAD.git master', '2018/12/29 16:41:25', 'master', 'e83c44200ab428b753a1e08a2e4d95
# target format: '0.18R14726 (Git)'
return '{0}.{1}R{2}'.format(*vertup)
except Exception:
return '0.18R14726 (Git)'
def makeFeatureFrame(part, featurepl):
obj = FreeCAD.ActiveDocument.addObject("App::FeaturePython",
"FeatureFrame")
FeatureFrame(obj, part, featurepl)
# If we're >0.16, add the feature frame to the assembly
if int(FreeCAD.Version()[1]) > 16:
geo_feature_group = part.getParentGeoFeatureGroup()
geo_feature_group.addObject(obj)
if FreeCAD.GuiUp:
ViewProviderFeatureFrame(obj.ViewObject)
return obj
def write_meta_data(self, data, node):
'''
Write the project and application data to the file
'''
self._write_tree_data(data, LandXml.get_child(node, 'Project'), maps.XML_ATTRIBS['Project'])
node = LandXml.get_child(node, 'Application')
node.set('version', ''.join(App.Version()[0:3]))
node.set('timeStamp', datetime.datetime.utcnow().isoformat())
def FreeCADVersion():
'returns version of FreeCAD (tuple of 3 ints)'
import FreeCAD as App
major, minor, rev = App.Version()[0:3]
#parse revision string, which looks like "10660 (Git)"
import re
match = re.match(r"(\d+).+", rev)
rev = int(match.groups()[0])
return (major, minor, rev)
def new_point(self):
if int(FreeCAD.Version()[1]) >= 19.:
# logger.warning('FreeCAD 19 or newer')
obj = self.Object.obj_list[self.Object.obj_combo.currentIndex()]
axis = self.axis_combo.currentText()
value = self.value_data.value()
if axis == 'd':
if 'axis_d' in obj.PropertiesList:
vec = obj.axis_d * value
if 'd_o' in obj.PropertiesList:
base = obj.d_o
base.append(vec)
obj.d_o = base
else:
obj.addProperty("App::PropertyVectorList", "d_o",
obj.Name, "Points o to d",
4).d_o = [vec]
else:
# mensaje de error para que el usuario fije unos ejes
self.message()
elif axis == 'w':
if 'axis_w' in obj.PropertiesList:
vec = obj.axis_w * value
if 'w_o' in obj.PropertiesList:
base = obj.w_o
base.append(vec)
obj.w_o = base
else:
obj.addProperty("App::PropertyVectorList", "w_o",
obj.Name, "Points o to w",
4).w_o = [vec]
else:
# mensaje de error para que el usuario fije unos ejes
self.message()
elif axis == 'h':
if 'axis_h' in obj.PropertiesList:
vec = obj.axis_h * value
if 'h_o' in obj.PropertiesList:
base = obj.h_o
base.append(vec)
obj.h_o = base
else:
obj.addProperty("App::PropertyVectorList", "h_o",
obj.Name, "Points o to h",
4).h_o = [vec]
else:
# mensaje de error para que el usuario fije unos ejes
self.message()
else:
# logger.error('Not working!!')
pass
else:
logger.warning(
'FreeCAD version need to be 19 or newer to use this utility')
