#!/usr/bin/env python3
# coding: utf-8
#
# libraries for FreeCAD's Assembly 4 workbench
#
# LGPL
# Copyright HUBERT Zoltán
"""
+-----------------------------------------------+
| shouldn't these be DEFINE's ? |
+-----------------------------------------------+
"""
import os
#__dir__ = os.path.dirname(__file__)
wbPath = os.path.dirname(__file__)
iconPath = os.path.join( wbPath, 'Resources/icons' )
libPath = os.path.join( wbPath, 'Resources/library' )
from PySide import QtGui, QtCore
import FreeCADGui as Gui
import FreeCAD as App
from FreeCAD import Console as FCC
# Types of datum objects
datumTypes = [ 'PartDesign::CoordinateSystem', \
'PartDesign::Plane', \
'PartDesign::Line', \
'PartDesign::Point']
partInfo =[ 'PartID', \
'PartName', \
'PartDescription', \
'PartSupplier']
containerTypes = [ 'App::Part', 'PartDesign::Body' ]
VEC_0 = App.Vector(0, 0, 0)
VEC_X = App.Vector(1, 0, 0)
VEC_Y = App.Vector(0, 1, 0)
VEC_Z = App.Vector(0, 0, 1)
VEC_T = App.Vector(1, 1, 1)
rotX = App.Placement( VEC_0, App.Rotation( VEC_X, 90) )
rotY = App.Placement( VEC_0, App.Rotation( VEC_Y, 90) )
rotZ = App.Placement( VEC_0, App.Rotation( VEC_Z, 90) )
def findObjectLink(obj, doc = App.ActiveDocument):
for o in doc.Objects:
if hasattr(o, 'LinkedObject'):
if o.LinkedObject == obj:
return o
return(None)
def getSelectionPath(docName, objName, subObjName):
val = []
if (docName is None) or (docName == ''):
docName = App.ActiveDocument.Name
val.append(docName)
if objName and (objName != ''):
val.append(objName)
if subObjName and (subObjName != ''):
for son in subObjName.split('.'):
if son and (son != ''):
val.append(son)
return val
"""
+-----------------------------------------------+
| Object helper functions |
+-----------------------------------------------+
"""
def cloneObject(obj):
container = obj.getParentGeoFeatureGroup()
result = None
if obj.Document and container:
#result = obj.Document.copyObject(obj, False)
result = obj.Document.addObject('App::Link', obj.Name)
result.LinkedObject = obj
result.Label = obj.Label
container.addObject(result)
result.recompute()
#container = result.getParentGeoFeatureGroup()
#if container:
container.recompute()
#if result.Document:
result.Document.recompute()
return result
def placeObjectToLCS( attObj, attLink, attDoc, attLCS ):
expr = makeExpressionDatum( attLink, attDoc, attLCS )
# FCC.PrintMessage('expression = '+expr)
# indicate the this fastener has been placed with the Assembly4 workbench
if not hasattr(attObj,'SolverId'):
makeAsmProperties(attObj)
# the fastener is attached by its Origin, no extra LCS
attObj.AttachedBy = 'Origin'
# store the part where we're attached to in the constraints object
attObj.AttachedTo = attLink+'#'+attLCS
# load the built expression into the Expression field of the constraint
attObj.setExpression( 'Placement', expr )
# Which solver is used
attObj.SolverId = 'Asm4EE'
# recompute the object to apply the placement:
attObj.recompute()
container = attObj.getParentGeoFeatureGroup()
if container:
container.recompute()
if attObj.Document:
attObj.Document.recompute()
"""
+-----------------------------------------------+
| Create default Assembly4 properties |
+-----------------------------------------------+
"""
def makeAsmProperties( obj, reset=False ):
# property AssemblyType
# DEPRECATED
'''
if not hasattr(obj,'AssemblyType'):
obj.addProperty( 'App::PropertyString', 'AssemblyType', 'Assembly' )
obj.setPropertyStatus('AssemblyType','ReadOnly')
'''
# property AttachedBy
if not hasattr(obj,'AttachedBy'):
obj.addProperty( 'App::PropertyString', 'AttachedBy', 'Assembly' )
obj.setPropertyStatus('AttachedBy' ,'ReadOnly')
# property AttachedTo
if not hasattr(obj,'AttachedTo'):
obj.addProperty( 'App::PropertyString', 'AttachedTo', 'Assembly' )
obj.setPropertyStatus('AttachedTo' ,'ReadOnly')
# property AttachmentOffset
if not hasattr(obj,'AttachmentOffset'):
obj.addProperty( 'App::PropertyPlacement', 'AttachmentOffset', 'Assembly' )
# property SolverId
if not hasattr(obj,'SolverId'):
obj.addProperty( 'App::PropertyString', 'SolverId', 'Assembly' )
if reset:
obj.AttachedBy = ''
obj.AttachedTo = ''
obj.AttachmentOffset = App.Placement()
obj.SolverId = ''
return
# checks whether there is a Variables container, and returns it
def getVarContainer():
retval = None
# check whether there already is a Variables object
variables = App.ActiveDocument.getObject('Variables')
if variables and variables.TypeId=='App::FeaturePython':
# signature of a PropertyContainer
if hasattr(variables,'Type') :
if variables.Type == 'App::PropertyContainer':
retval = variables
return retval
# the Variables container
def makeVarContainer():
retval = None
# check whether there already is a Variables object
variables = App.ActiveDocument.getObject('Variables')
if variables :
if variables.TypeId=='App::FeaturePython':
# signature of a PropertyContainer
if hasattr(variables,'Type') :
if variables.Type == 'App::PropertyContainer':
retval = variables
# for compatibility
else:
variables.addProperty('App::PropertyString', 'Type')
variables.Type = 'App::PropertyContainer'
retval = variables
else:
FCC.PrintWarning('This Part contains an incompatible \"Variables\" object, ')
FCC.PrintWarning('this could lead to unexpected results\n')
# there is none, so we create it
else:
variables = App.ActiveDocument.addObject('App::FeaturePython','Variables')
variables.ViewObject.Proxy = setCustomIcon(object,'Asm4_Variables.svg')
# signature or a PropertyContainer
variables.addProperty('App::PropertyString', 'Type')
variables.Type = 'App::PropertyContainer'
retval = variables
return retval
# custom icon
# views/view_custom.py
# https://wiki.freecadweb.org/Viewprovider
# https://wiki.freecadweb.org/Custom_icon_in_tree_view
#
# obj = App.ActiveDocument.addObject("App::FeaturePython", "Name")
# obj.ViewObject.Proxy = ViewProviderCustomIcon( obj, path + "FreeCADIco.png")
# icon download to file
#
# usage:
# object = App.ActiveDocument.addObject('App::FeaturePython','objName')
# object = model.newObject('App::FeaturePython','objName')
# object.ViewObject.Proxy = Asm4.setCustomIcon(object,'Asm4_Variables.svg')
class setCustomIcon():
def __init__( self, obj, iconFile):
#obj.Proxy = self
self.customIcon = os.path.join( iconPath, iconFile )
def getIcon(self): # GetIcon
return self.customIcon
"""
+-----------------------------------------------+
| check whether a workbench exists |
+-----------------------------------------------+
"""
def checkWorkbench( workbench ):
# checks whether the specified workbench is installed
listWB = Gui.listWorkbenches()
hasWB = False
for wb in listWB.keys():
if wb == workbench:
hasWB = True
return hasWB
# since Asm4 v0.20 an assembly is called "Assembly" again
def getAssembly():
# return checkModel()
retval = None
if App.ActiveDocument:
# the current (as per v0.90) assembly container
assy = App.ActiveDocument.getObject('Assembly')
if assy and assy.TypeId == 'App::Part' \
and assy.Type == 'Assembly' \
and assy.getParentGeoFeatureGroup() is None:
retval = assy
else:
# former Asm4 Model compatibility check:
model = App.ActiveDocument.getObject('Model')
if model and model.TypeId == 'App::Part' \
and model.Type == 'Assembly' \
and model.getParentGeoFeatureGroup() is None:
retval = model
else:
# last chance, very old Asm4 Model
if model and model.TypeId=='App::Part' \
and model.getParentGeoFeatureGroup() is None:
FCC.PrintMessage("Deprecated Asm4 Model detected, this could lead to uncompatibilities\n")
retval = model
return retval
# checks and returns whether there is an Asm4 Assembly Model in the active document
# DEPRECATED : it's called Assembly again
def checkModel():
return getAssembly()
'''
retval = None
if App.ActiveDocument:
model = App.ActiveDocument.getObject('Model')
# the current (as per v0.12) assembly container
if model and model.TypeId=='App::Part' \
and model.Type == 'Assembly' \
and model.getParentGeoFeatureGroup() is None:
retval = model
else:
# former Assembly compatibility check:
assy = App.ActiveDocument.getObject('Assembly')
if assy and assy.TypeId=='App::Part' \
and assy.Type == 'Assembly' \
and assy.getParentGeoFeatureGroup() is None:
retval = assy
else:
# last chance, very old Asm4 Model
if model and model.TypeId=='App::Part' \
and model.getParentGeoFeatureGroup() is None:
retval = model
return retval
'''
# returns the selected object and its selection hierarchy
# the first element in the tree is the uppermost container name
# the last is the object name
# elements are separated by '.' (dot)
# usage:
# ( obj, tree ) = Asm4.getSelectionTree(index=0)
def getSelectionTree(index=0):
retval = (None,None)
# we obviously need something selected
# if len(Gui.Selection.getSelection()) >= index:
if len(Gui.Selection.getSelection()) > index:
selObj = Gui.Selection.getSelection()[index]
retval = ( selObj, None )
# objects at the document root don't have a selection tree
if len(Gui.Selection.getSelectionEx("", 0)[0].SubElementNames) >= index:
# we only treat thefirst selected object
# this is a dot-separated list of the selection hierarchy
selList = Gui.Selection.getSelectionEx("", 0)[0].SubElementNames[index]
# this is the final tree table
# this first element will be overwritten later
selTree = ['root part']
# parse the list to find all objects
rest = selList
while rest:
(parent, dot, rest) = rest.partition('.')
# FCC.PrintMessage('found '+parent+'\n')
selTree.append(parent)
# if we did find things
if len(selTree)>1:
# if the last one is not the selected object, it might be a sub-element of it
if selTree[-1]!=selObj.Name:
selTree = selTree[0:-1]
# the last one should the selected object
if selTree[-1]==selObj.Name:
topObj = App.ActiveDocument.getObject(selTree[1])
rootObj = topObj.getParentGeoFeatureGroup()
selTree[0] = rootObj.Name
# all went well, we return the selected object and it's tree
retval = ( selObj, selTree )
return retval
# get all datums in a part
def getPartLCS( part ):
partLCS = [ ]
# parse all objects in the part (they return strings)
for objName in part.getSubObjects(1):
# get the proper objects
# all object names end with a "." , this needs to be removed
obj = part.getObject( objName[0:-1] )
if obj.TypeId in datumTypes:
partLCS.append( obj )
elif obj.TypeId == 'App::DocumentObjectGroup':
datums = getPartLCS(obj)
for datum in datums:
partLCS.append(datum)
return partLCS
# get the document group called Part
# (if it exists, else return None
def getPartsGroup():
retval = None
partsGroup = App.ActiveDocument.getObject('Parts')
if partsGroup and partsGroup.TypeId=='App::DocumentObjectGroup':
retval = partsGroup
return retval
# Get almost all Objects within the passed Selection.
# A Selection is one or more marked Object(s) anywhere
# in the opened Document. The idea is to get a similar
# Selection back, as If you would "copy" the marked Objects.
# The Window that pops up and shows are affected Objects, calls it
# The Dependencies
# Objects within Compounds and Bodys and also Linked Objects are left out.
#
# NOTE: Theoretically we could use the App.ActiveDocument.DependencyGraph function,
# to get really every Object behind a selection.
def getDependenciesList( CompleteSelection ):
deDendenciesList = [ ]
for Selection in CompleteSelection:
# A possible container for more Sub-Objects
SubObjects = [ ]
# If an Object has more objects to offer, get them
if hasattr(Selection,'getSubObjects'):
SubObjNames=Selection.getSubObjects()
# Some Objects return None Objects,
# even if it has the 'getSubObjects' attribute
# 'getSubObjects' delivers unique Names with a trailing .
for SubObjName in SubObjNames:
SubObjects.append(App.ActiveDocument.getObject(SubObjName[0:-1]))
# If they are more Sub-Objects within that particular selection,
# go get them. It doesn't matter If it is a Group or Part or Link.
if SubObjects is not None:
SubObjects = getDependenciesList(SubObjects)
# Adding the Sub-Objects in that way, prevents nested Objects in Objects
for SubObject in SubObjects:
deDendenciesList.append(SubObject)
# In order to make not iterable, single Objects,
# iterable enclosing [] are needed
deDendenciesList.append([Selection])
return deDendenciesList
"""
+-----------------------------------------------+
| get the next instance's name |
+-----------------------------------------------+
"""
def nextInstance( name, startAtOne=False ):
# if there is no such name, return the original
if not App.ActiveDocument.getObject(name) and not startAtOne:
return name
# there is already one, we increment
else:
if startAtOne:
instanceNum = 1
else:
instanceNum = 2
while App.ActiveDocument.getObject( name+'_'+str(instanceNum) ):
instanceNum += 1
return name+'_'+str(instanceNum)
"""
+-----------------------------------------------+
| return the ExpressionEngine |
| of the Placement property |
+-----------------------------------------------+
"""
def placementEE( EE ):
if not EE:
return None
else:
for expr in EE:
if expr[0] == 'Placement':
return expr[1]
return None
"""
+-----------------------------------------------+
| some geometry tests |
+-----------------------------------------------+
"""
def isVector( vect ):
if isinstance(vect,App.Vector):
return True
return False
def isCircle(shape):
if shape.isValid() and hasattr(shape,'Curve') \
and shape.Curve.TypeId=='Part::GeomCircle' \
and hasattr(shape.Curve,'Center') \
and hasattr(shape.Curve,'Radius'):
return True
return False
def isLine(shape):
if shape.isValid() and hasattr(shape,'Curve') \
and shape.Curve.TypeId=='Part::GeomLine' \
and hasattr(shape,'Placement'):
return True
return False
def isSegment(shape):
if shape.isValid() and hasattr(shape,'Curve') \
and shape.Curve.TypeId=='Part::GeomLine' \
and hasattr(shape,'Length') \
and hasattr(shape,'Vertexes') \
and len(shape.Vertexes)==2:
return True
return False
def isFlatFace(shape):
if shape.isValid() and hasattr(shape,'Area') \
and shape.Area > 1.0e-6 \
and hasattr(shape,'Volume') \
and shape.Volume < 1.0e-9:
return True
return False
def isHoleAxis(obj):
if not obj:
return False
if hasattr(obj, 'AttacherType'):
if obj.AttacherType == 'Attacher::AttachEngineLine':
return True
return False
def isPart(obj):
if not obj:
return False
if hasattr(obj, 'TypeId'):
if obj.TypeId == 'App::Part':
return True
return False
def isAppLink(obj):
if not obj:
return False
if hasattr(obj, 'TypeId') and obj.TypeId == 'App::Link':
return True
return False
def isLinkToPart(obj):
if not obj:
return False
if obj.TypeId == 'App::Link' and hasattr(obj.LinkedObject,'isDerivedFrom'):
if obj.LinkedObject.isDerivedFrom('App::Part') or obj.LinkedObject.isDerivedFrom('PartDesign::Body'):
return True
return False
'''
def isPartLinkAssembly(obj):
if not obj:
return False
if hasattr(obj,'AssemblyType') and hasattr(obj,'SolverId'):
if obj.AssemblyType == 'Part::Link' or obj.AssemblyType == '' :
return True
return False
'''
def isAsm4EE(obj):
if not obj:
return False
# we only need to check for the SolverId
if hasattr(obj,'SolverId') :
if obj.SolverId=='Asm4EE' or obj.SolverId=='Placement::ExpressionEngine' or obj.SolverId=='' :
return True
# legacy check
# DEPRECATED, to be removed
elif hasattr(obj,'AssemblyType') :
if obj.AssemblyType == 'Asm4EE' or obj.AssemblyType == '' :
FCC.PrintMessage('Found legacy AssemblyType property, adding new empty SolverId property\n')
# add the new property to convert legacy object
obj.addProperty( 'App::PropertyString', 'SolverId', 'Assembly' )
return True
return False
def isAssembly(obj):
if not obj:
return False
if obj.TypeId=='App::Part' and obj.Name=='Assembly':
if hasattr(obj,'Type') and obj.Type=='Assembly':
return True
return False
def isAsm4Model(obj):
return isAssembly(obj)
"""
+-----------------------------------------------+
| Shows a Warning message box |
+-----------------------------------------------+
"""
def warningBox( text ):
msgBox = QtGui.QMessageBox()
msgBox.setWindowTitle( 'FreeCAD Warning' )
msgBox.setIcon( QtGui.QMessageBox.Critical )
msgBox.setText( text )
msgBox.exec_()
return
def confirmBox( text ):
msgBox = QtGui.QMessageBox()
msgBox.setWindowTitle('FreeCAD Warning')
msgBox.setIcon(QtGui.QMessageBox.Warning)
msgBox.setText(text)
msgBox.setInformativeText('Are you sure you want to proceed ?')
msgBox.setStandardButtons(QtGui.QMessageBox.Cancel | QtGui.QMessageBox.Ok)
msgBox.setEscapeButton(QtGui.QMessageBox.Cancel)
msgBox.setDefaultButton(QtGui.QMessageBox.Ok)
retval = msgBox.exec_()
# Cancel = 4194304
# Ok = 1024
if retval == 1024:
# user confirmed
return True
# anything else than OK
return False
"""
+-----------------------------------------------+
| Drop-down menu to group buttons |
+-----------------------------------------------+
"""
# from https://github.com/HakanSeven12/FreeCAD-Geomatics-Workbench/commit/d82d27b47fcf794bf6f9825405eacc284de18996
class dropDownCmd:
def __init__(self, cmdlist, menu, tooltip = None, icon = None):
self.cmdlist = cmdlist
self.menu = menu
if tooltip is None:
self.tooltip = menu
else:
self.tooltip = tooltip
def GetCommands(self):
return tuple(self.cmdlist)
def GetResources(self):
return { 'MenuText': self.menu, 'ToolTip': self.tooltip }
"""
+-----------------------------------------------+
| returns the object Label (Name) |
+-----------------------------------------------+
"""
# Label (Name)
def labelName( obj ):
if obj:
if obj.Name == obj.Label:
txt = obj.Label
else:
txt = obj.Label +' ('+obj.Name+')'
return txt
else:
return None
"""
+-----------------------------------------------+
| populate the ExpressionEngine |
+-----------------------------------------------+
"""
def makeExpressionPart( attLink, attDoc, attLCS, linkedDoc, linkLCS ):
# if everything is defined
if attLink and attLCS and linkedDoc and linkLCS:
# this is where all the magic is, see:
#
# https://forum.freecadweb.org/viewtopic.php?p=278124#p278124
#
# as of FreeCAD v0.19 the syntax is different:
# https://forum.freecadweb.org/viewtopic.php?f=17&t=38974&p=337784#p337784
# expr = ParentLink.Placement * ParentPart#LCS.Placement * constr_LinkName.AttachmentOffset * LinkedPart#LCS.Placement ^ -1
# expr = LCS_in_the_assembly.Placement * constr_LinkName.AttachmentOffset * LinkedPart#LCS.Placement ^ -1
# the AttachmentOffset is now a property of the App::Link
# expr = LCS_in_the_assembly.Placement * AttachmentOffset * LinkedPart#LCS.Placement ^ -1
expr = attLCS+'.Placement * AttachmentOffset * '+linkedDoc+'#'+linkLCS+'.Placement ^ -1'
# if we're attached to another sister part (and not the Parent Assembly)
# we need to take into account the Placement of that Part.
if attDoc:
expr = attLink+'.Placement * '+attDoc+'#'+expr
else:
expr = False
return expr
def makeExpressionDatum( attLink, attPart, attLCS ):
# check that everything is defined
if attLCS:
# expr = Link.Placement * LinkedPart#LCS.Placement
expr = attLCS +'.Placement * AttachmentOffset'
if attLink and attPart:
expr = attLink+'.Placement * '+attPart+'#'+expr
else:
expr = None
return expr
"""
+-----------------------------------------------+
| ExpressionEngine for Fasteners |
+-----------------------------------------------+
"""
# is in the FastenersLib.py file
# checks whether an App::Part is selected, and that it's at the root of the document
def getSelectedRootPart():
retval = None
selection = Gui.Selection.getSelection()
if len(selection)==1:
selObj = selection[0]
# only consider App::Parts at the root of the document
if selObj.TypeId=='App::Part' and selObj.getParentGeoFeatureGroup() is None:
retval = selObj
return retval
def getSelectedContainer():
retval = None
selection = Gui.Selection.getSelection()
if len(selection)==1:
selObj = selection[0]
if selObj.TypeId in containerTypes:
retval = selObj
return retval
# returns the selected App::Link
def getSelectedLink():
retval = None
selection = Gui.Selection.getSelection()
if len(selection)==1:
selObj = selection[0]
# it's an App::Link
if selObj.isDerivedFrom('App::Link') and selObj.LinkedObject is not None and selObj.LinkedObject.TypeId in containerTypes:
retval = selObj
return retval
# returns the selected Asm4 variant link
def getSelectedVarLink():
retval = None
selection = Gui.Selection.getSelection()
if len(selection)==1:
selObj = selection[0]
# it's an App::Link
if selObj.TypeId=='Part::FeaturePython':
if hasattr(selObj,'Type') and selObj.Type=='Asm4::VariantLink':
retval = selObj
return retval
def getSelectedDatum():
selectedObj = None
# check that something is selected
if len(Gui.Selection.getSelection())==1:
selection = Gui.Selection.getSelection()[0]
# check that it's a datum
if selection.TypeId in datumTypes:
selectedObj = selection
# now we should be safe
return selectedObj
def create_assembly():
# provision to supply a document in create_assembly call different
# from App.ActiveDocument. This sohould however modify each calls
# like getAssembly and similar methods.
d_doc = App.ActiveDocument
# check whether there is already Model in the document
# assy = App.ActiveDocument.getObject('Assembly')
assy = getAssembly()
if assy is not None:
if assy.TypeId=='App::Part':
message = "This document already contains a valid Assembly, please use it"
warningBox(message)
# set the Type to Assembly
assy.Type = 'Assembly'
else:
message = "This document already contains another FreeCAD object called \"Assembly\", "
message += "but it's of type \""+assy.TypeId+"\", unsuitable for an assembly. I can\'t proceed."
warningBox(message)
# abort
return
# there is no object called "Assembly"
# create a group 'Parts' to hold all parts in the assembly document (if any)
# must be done before creating the assembly
partsGroup = d_doc.getObject('Parts')
if partsGroup is None:
partsGroup = d_doc.addObject( 'App::DocumentObjectGroup', 'Parts' )
# create a new App::Part called 'Assembly'
assembly = d_doc.addObject('App::Part','Assembly')
# set the type as a "proof" that it's an Assembly
assembly.Type='Assembly'
assembly.addProperty( 'App::PropertyString', 'AssemblyType', 'Assembly' )
assembly.AssemblyType = 'Part::Link'
# add an LCS at the root of the Model, and attach it to the 'Origin'
lcs0 = assembly.newObject('PartDesign::CoordinateSystem','LCS_Origin')
lcs0.Support = [(assembly.Origin.OriginFeatures[0],'')]
lcs0.MapMode = 'ObjectXY'
lcs0.MapReversed = False
# create a group Constraints to store future solver constraints there
assembly.newObject('App::DocumentObjectGroup','Constraints')
d_doc.getObject('Constraints').Visibility = False
# create an object Variables to hold variables to be used in this document
assembly.addObject(makeVarContainer())
# create a group Configurations to store future solver constraints there
assembly.newObject('App::DocumentObjectGroup','Configurations')
d_doc.getObject('Configurations').Visibility = False
# move existing parts and bodies at the document root to the Parts group
# not nested inside other parts, to keep hierarchy
if partsGroup.TypeId=='App::DocumentObjectGroup':
for obj in d_doc.Objects:
if obj.TypeId in containerTypes and obj.Name!='Assembly' and obj.getParentGeoFeatureGroup() is None:
partsGroup.addObject(obj)
else:
warningBox( 'There seems to already be a Parts object, you might get unexpected behaviour' )
# recompute to get rid of the small overlays
assembly.recompute()
d_doc.recompute()
"""
+-----------------------------------------------+
| Unit Spin Box |
+-----------------------------------------------+
usage:
self.YtranslSpinBox = QtGui.QDoubleSpinBox() → self.YtranslSpinBox = Asm4.QUnitSpinBox()
"""
class QUnitSpinBox(QtGui.QDoubleSpinBox):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
_, self.length_divisor, self.default_unit = (
App.Units.schemaTranslate(
App.Units.Quantity("1 mm"),
App.Units.getSchema()
)
)
self.setSuffix(" " + self.default_unit)
def value(self) -> float:
"""gets the value in mm"""
return super().value() * self.length_divisor
def setValue(self, distance: float):
"""sets the value in mm"""
return super().setValue(
distance / self.length_divisor,
)