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')