def run_FreeCAD_RefList(self,*args, **kwargs): if 0: pintyp="VectorPin" pinname="Base" p2 = CreateRawPin(pinname,self, pintyp, PinDirection.Input) try: uiPin = self.getWrapper()._createUIPinWrapper(p2) uiPin.setDisplayName("{}".format(p2.name)) except: pass #clean up pins=self.getOrderedPins() for p in pins: if not p.isExec() and p.direction != PinDirection.Input : p.kill() name="objects" pinname=name pintyp="ShapeListPin" p2 = CreateRawPin(pinname,self, pintyp, PinDirection.Output) try: uiPin = self.getWrapper()._createUIPinWrapper(p2) uiPin.setDisplayName("{}".format(p2.name)) except: pass # self.setPinObject(pinname,subob) ss=FreeCADGui.Selection.getSelection() self.setPinObjects(pinname,ss)
def recreateOutput(self, dataType): self.out.kill() del self.out self.out = None self.out = CreateRawPin('value', self, dataType, PinDirection.Output) self.out.enableOptions(PinOptions.RenamingEnabled) return self.out
def recreateInput(self, dataType): self.inp.kill() del self.inp self.inp = None self.inp = CreateRawPin('value', self, dataType, PinDirection.Input) self.inp.disableOptions(PinOptions.RenamingEnabled) return self.out
def __init__(self, name, var=None): super(setVar, self).__init__(name) self.inExec = self.createInputPin(DEFAULT_IN_EXEC_NAME, 'ExecPin', None, self.compute) self.outExec = self.createOutputPin(DEFAULT_OUT_EXEC_NAME, 'ExecPin') self.var = var self.inp = CreateRawPin("inp", self, self.var.dataType, PinDirection.Input) self.out = CreateRawPin("out", self, self.var.dataType, PinDirection.Output) self.var.killed.connect(self.kill)
def __init__(self, name, var=None): super(getVar, self).__init__(name) assert (isinstance(var, Variable)) self.var = var self.out = CreateRawPin('value', self, var.dataType, PinDirection.Output) self.out.disableOptions(PinOptions.RenamingEnabled) self.var.valueChanged.connect(self.onVarValueChanged)
def recreateOutput(self, dataType): self.out.kill() del self.out self.out = None self.out = CreateRawPin('out', self, dataType, PinDirection.Output) self.out.disableOptions(PinOptions.RenamingEnabled) self.updateStructure() return self.out
def __init__(self, name, var=None): super(setVar, self).__init__(name) self.inExec = self.createInputPin(DEFAULT_IN_EXEC_NAME, 'ExecPin', None, self.compute) self.outExec = self.createOutputPin(DEFAULT_OUT_EXEC_NAME, 'ExecPin') self.var = var self.inp = CreateRawPin("value", self, self.var.dataType, PinDirection.Input) self.inp.disableOptions(PinOptions.RenamingEnabled) self.out = CreateRawPin("value", self, self.var.dataType, PinDirection.Output) self.out.disableOptions(PinOptions.RenamingEnabled)
def __init__(self, name, var=None): super(setVar, self).__init__(name) self.inExec = self.createInputPin(DEFAULT_IN_EXEC_NAME, 'ExecPin', None, self.compute) self.outExec = self.createOutputPin(DEFAULT_OUT_EXEC_NAME, 'ExecPin') self._var = var self.inp = CreateRawPin("inp", self, self._var.dataType, PinDirection.Input) self.inp.disableOptions(PinOptions.RenamingEnabled) self.out = CreateRawPin("out", self, self._var.dataType, PinDirection.Output) self.out.disableOptions(PinOptions.RenamingEnabled) self._var.dataTypeChanged.connect(self.onVarDataTypeChanged) self._var.structureChanged.connect(self.onVarStructureChanged) self.bCacheEnabled = False
class setVar(NodeBase): def __init__(self, name, var=None): super(setVar, self).__init__(name) self.inExec = self.createInputPin(DEFAULT_IN_EXEC_NAME, 'ExecPin', None, self.compute) self.outExec = self.createOutputPin(DEFAULT_OUT_EXEC_NAME, 'ExecPin') self.var = var self.inp = CreateRawPin("inp", self, self.var.dataType, PinDirection.Input) self.out = CreateRawPin("out", self, self.var.dataType, PinDirection.Output) self.var.killed.connect(self.kill) def variableUid(self): return self.var.uid def serialize(self): default = NodeBase.serialize(self) default['varUid'] = str(self.var.uid) return default @staticmethod def pinTypeHints(): return {'inputs': [], 'outputs': []} @staticmethod def category(): return PACKAGE_NAME @staticmethod def keywords(): return ["set", "var"] @staticmethod def description(): return 'Set variable value' def compute(self, *args, **kwargs): newValue = self.inp.getData() self.var.value = newValue self.out.setData(copy(self.var.value)) self.outExec.call(*args, **kwargs)
class getVar(NodeBase): def __init__(self, name, var=None): super(getVar, self).__init__(name) assert (isinstance(var, Variable)) self.var = var self.out = CreateRawPin('value', self, var.dataType, PinDirection.Output) self.out.enableOptions(PinOptions.RenamingEnabled) self.var.valueChanged.connect(self.onVarValueChanged) self.var.killed.connect(self.kill) def variableUid(self): return self.var.uid def recreateOutput(self, dataType): self.out.kill() del self.out self.out = None self.out = CreateRawPin('value', self, dataType, PinDirection.Output) self.out.enableOptions(PinOptions.RenamingEnabled) return self.out def onVarValueChanged(self, *args, **kwargs): push(self.out) def serialize(self): default = NodeBase.serialize(self) default['varUid'] = str(self.var.uid) return default @staticmethod def pinTypeHints(): return {'inputs': [], 'outputs': []} @staticmethod def category(): return PACKAGE_NAME @staticmethod def keywords(): return ["get", "var"] @staticmethod def description(): return 'Access variable value' def compute(self, *args, **kwargs): self.out.setData(copy(self.var.value))
class getVar(NodeBase): def __init__(self, name, var=None): super(getVar, self).__init__(name) assert (isinstance(var, Variable)) self._var = var if var.structure == StructureType.Dict: self.out = self.createOutputPin('out', var.value.keyType, structure=StructureType.Dict) else: self.out = self.createOutputPin('out', var.dataType) self.out.disableOptions(PinOptions.RenamingEnabled) self._var.valueChanged.connect(self.onVarValueChanged) self._var.structureChanged.connect(self.onVarStructureChanged) self._var.dataTypeChanged.connect(self.onDataTypeChanged) self.bCacheEnabled = False def checkForErrors(self): super(getVar, self).checkForErrors() if self._var is None: self.setError("Undefined variable") def onDataTypeChanged(self, dataType): self.recreateOutput(dataType) self.checkForErrors() wrapper = self.getWrapper() if wrapper: wrapper.onVariableWasChanged() def updateStructure(self): self.out.disconnectAll() if self._var.structure == StructureType.Single: self.out.setAsArray(False) if self._var.structure == StructureType.Array: self.out.setAsArray(True) if self._var.structure == StructureType.Dict: self.out.setAsDict(True) # self.out._keyType = self.var.value.keyType def onVarStructureChanged(self, newStructure): self.out.structureType = newStructure self.updateStructure() def recreateOutput(self, dataType): self.out.kill() del self.out self.out = None self.out = CreateRawPin('out', self, dataType, PinDirection.Output) self.out.disableOptions(PinOptions.RenamingEnabled) self.updateStructure() return self.out @property def var(self): return self._var @var.setter def var(self, newVar): if self._var is not None: self._var.dataTypeChanged.disconnect(self.onDataTypeChanged) self._var.structureChanged.disconnect(self.onVarStructureChanged) self._var.valueChanged.disconnect(self.onVarValueChanged) self._var = newVar if newVar is not None: self._var.valueChanged.connect(self.onVarValueChanged) self._var.structureChanged.connect(self.onVarStructureChanged) self._var.dataTypeChanged.connect(self.onDataTypeChanged) self.recreateOutput(self._var.dataType) else: # self.out.kill() # del self.out # self.out = None pass self.checkForErrors() wrapper = self.getWrapper() if wrapper: wrapper.onVariableWasChanged() def postCreate(self, jsonTemplate=None): super(getVar, self).postCreate(jsonTemplate) self.updateStructure() def variableUid(self): return self.var.uid def onVarValueChanged(self, *args, **kwargs): push(self.out) def serialize(self): default = NodeBase.serialize(self) if self.var is not None: default['varUid'] = str(self.var.uid) return default @staticmethod def category(): return PACKAGE_NAME @staticmethod def keywords(): return ["get", "var"] @staticmethod def description(): return 'Access variable value' def compute(self, *args, **kwargs): self.out.setData(copy(self.var.value))
def createOutputPin(self, *args, **kwargs): pinName = str(len(self.outputs) + 1) p = CreateRawPin(pinName, self, 'ExecPin', PinDirection.Output) p.enableOptions(PinOptions.Dynamic) return p
def createOutputPin(self, pinName, dataType, defaultValue=None, structure=PinStructure.Single, constraint=None, structConstraint=None, allowedPins=[], group=""): pinName = self.getUniqPinName(pinName) p = CreateRawPin(pinName, self, dataType, PinDirection.Output) p.structureType = structure p.group = group if structure == PinStructure.Array: p.initAsArray(True) elif structure == PinStructure.Multi: p.enableOptions(PinOptions.ArraySupported) if defaultValue is not None: p.setDefaultValue(defaultValue) p.setData(defaultValue) else: p.setDefaultValue(getPinDefaultValueByType(dataType)) if dataType == "AnyPin" and allowedPins: def supportedDataTypes(): return allowedPins p.supportedDataTypes = supportedDataTypes if constraint is not None: p.updateConstraint(constraint) if structConstraint is not None: p.updatestructConstraint(structConstraint) return p
def createInputPin(self, pinName, dataType, defaultValue=None, foo=None, structure=PinStructure.Single, constraint=None, structConstraint=None, allowedPins=[], group=""): # check unique name pinName = self.getUniqPinName(pinName) p = CreateRawPin(pinName, self, dataType, PinDirection.Input) p.structureType = structure p.group = group if structure == PinStructure.Array: p.initAsArray(True) elif structure == PinStructure.Multi: p.enableOptions(PinOptions.ArraySupported) if foo: p.onExecute.connect(foo, weak=False) if defaultValue is not None: p.setDefaultValue(defaultValue) p.setData(defaultValue) else: p.setDefaultValue(getPinDefaultValueByType(dataType)) if dataType == "AnyPin" and allowedPins: def supportedDataTypes(): return allowedPins p._supportedDataTypes = p._defaultSupportedDataTypes = tuple( allowedPins) p.supportedDataTypes = supportedDataTypes if constraint is not None: p.updateConstraint(constraint) if structConstraint is not None: p.updatestructConstraint(structConstraint) return p
def createOutputPin(self, pinName, dataType, defaultValue=None, structure=PinStructure.Single, constraint=None, structConstraint=None, supportedPinDataTypes=[], group=""): """Creates output pin :param pinName: Pin name :type pinName: str :param dataType: Pin data type :type dataType: str :param defaultValue: Pin default value :type defaultValue: object :param structure: Pin structure :type structure: :class:`~PyFlow.Core.Common.PinStructure.Single` :param constraint: Pin constraint. Should be any hashable type. We use str :type constraint: object :param structConstraint: Pin struct constraint. Also should be hashable type :type structConstraint: object :param supportedPinDataTypes: List of allowed pin data types to be connected. Used by AnyPin :type supportedPinDataTypes: list(str) :param group: Pin group. Used only by ui wrapper :type group: str """ pinName = self.getUniqPinName(pinName) p = CreateRawPin(pinName, self, dataType, PinDirection.Output) p.structureType = structure p.group = group if structure == PinStructure.Array: p.initAsArray(True) elif structure == PinStructure.Dict: p.initAsDict(True) elif structure == PinStructure.Multi: p.enableOptions(PinOptions.ArraySupported) if defaultValue is not None or dataType == "AnyPin": p.setDefaultValue(defaultValue) p.setData(defaultValue) if dataType == "AnyPin": p.setTypeFromData(defaultValue) else: p.setDefaultValue(getPinDefaultValueByType(dataType)) if dataType == "AnyPin" and supportedPinDataTypes: def supportedDataTypes(): return supportedPinDataTypes p.supportedDataTypes = supportedDataTypes if constraint is not None: p.updateConstraint(constraint) if structConstraint is not None: p.updateStructConstraint(structConstraint) return p
def createInputPin(self, pinName, dataType, defaultValue=None, foo=None, structure=StructureType.Single, constraint=None, structConstraint=None, supportedPinDataTypes=[], group=""): """Creates input pin :param pinName: Pin name :type pinName: str :param dataType: Pin data type :type dataType: str :param defaultValue: Pin default value :type defaultValue: object :param foo: Pin callback. used for exec pins :type foo: function :param structure: Pin structure :type structure: :class:`~PyFlow.Core.Common.StructureType.Single` :param constraint: Pin constraint. Should be any hashable type. We use str :type constraint: object :param structConstraint: Pin struct constraint. Also should be hashable type :type structConstraint: object :param supportedPinDataTypes: List of allowed pin data types to be connected. Used by AnyPin :type supportedPinDataTypes: list(str) :param group: Pin group. Used only by ui wrapper :type group: str """ pinName = self.getUniqPinName(pinName) p = CreateRawPin(pinName, self, dataType, PinDirection.Input) p.structureType = structure p.group = group if structure == StructureType.Array: p.initAsArray(True) elif structure == StructureType.Dict: p.initAsDict(True) elif structure == StructureType.Multi: p.enableOptions(PinOptions.ArraySupported) if foo: p.onExecute.connect(foo, weak=False) if defaultValue is not None or dataType == "AnyPin": p.setDefaultValue(defaultValue) p.setData(defaultValue) if dataType == "AnyPin": p.setTypeFromData(defaultValue) else: p.setDefaultValue(getPinDefaultValueByType(dataType)) if dataType == "AnyPin" and supportedPinDataTypes: def supportedDataTypes(): return supportedPinDataTypes p._supportedDataTypes = p._defaultSupportedDataTypes = tuple( supportedPinDataTypes) p.supportedDataTypes = supportedDataTypes if constraint is not None: p.updateConstraint(constraint) if structConstraint is not None: p.updateStructConstraint(structConstraint) p.dataBeenSet.connect(self.setDirty.send) p.markedAsDirty.connect(self.setDirty.send) return p
def createInputPin(self, pinName, dataType, defaultValue=None, foo=None, structure=PinStructure.Single, constraint=None, structConstraint=None, allowedPins=[]): # if dataType == 'ExecPin': # assert(foo is not None), "Invalid parameters for input exec pin. Call function must be specified" # check unique name pinName = self.getUniqPinName(pinName) p = CreateRawPin(pinName, self, dataType, PinDirection.Input) p.direction = PinDirection.Input p.structureType = structure if structure == PinStructure.Array: p.initAsArray(True) elif structure == PinStructure.Multi: p.enableOptions(PinOptions.ArraySupported) if foo: # p.call = foo p.onExecute.connect(foo, weak=False) if defaultValue is not None: p.setDefaultValue(defaultValue) p.setData(defaultValue) if dataType == "AnyPin" and allowedPins: def supportedDataTypes(): return allowedPins p._supportedDataTypes = p._defaultSupportedDataTypes = tuple( allowedPins) p.supportedDataTypes = supportedDataTypes if constraint is not None: p.updateConstraint(constraint) if structConstraint is not None: p.updatestructConstraint(structConstraint) return p
class setVar(NodeBase): def __init__(self, name, var=None): super(setVar, self).__init__(name) self.inExec = self.createInputPin(DEFAULT_IN_EXEC_NAME, 'ExecPin', None, self.compute) self.outExec = self.createOutputPin(DEFAULT_OUT_EXEC_NAME, 'ExecPin') self._var = var self.inp = CreateRawPin("inp", self, self._var.dataType, PinDirection.Input) self.inp.disableOptions(PinOptions.RenamingEnabled) self.out = CreateRawPin("out", self, self._var.dataType, PinDirection.Output) self.out.disableOptions(PinOptions.RenamingEnabled) self._var.dataTypeChanged.connect(self.onVarDataTypeChanged) self._var.structureChanged.connect(self.onVarStructureChanged) def updateStructure(self): self.out.disconnectAll() self.inp.disconnectAll() if self.var.structure == PinStructure.Single: self.out.setAsArray(False) self.inp.setAsArray(False) if self.var.structure == PinStructure.Array: self.out.setAsArray(True) self.inp.setAsArray(True) def checkForErrors(self): super(setVar, self).checkForErrors() if self._var is None: self.setError("Undefined variable") def onVarStructureChanged(self, newStructure): self.out.structureType = newStructure self.inp.structureType = newStructure self.updateStructure() def onVarDataTypeChanged(self, dataType): self.recreateInput(dataType) self.recreateOutput(dataType) self.autoAffectPins() self.updateStructure() self.checkForErrors() wrapper = self.getWrapper() if wrapper: wrapper.onVariableWasChanged() def postCreate(self, jsonTemplate=None): super(setVar, self).postCreate(jsonTemplate) self.updateStructure() @property def var(self): return self._var @var.setter def var(self, newVar): if self._var is not None: self._var.structureChanged.disconnect(self.onVarStructureChanged) self._var.dataTypeChanged.disconnect(self.onVarDataTypeChanged) self._var = newVar if self._var is not None: self._var.structureChanged.connect(self.onVarStructureChanged) self._var.dataTypeChanged.connect(self.onVarDataTypeChanged) self.recreateInput(newVar.dataType) self.recreateOutput(newVar.dataType) self.autoAffectPins() self.updateStructure() self.checkForErrors() wrapper = self.getWrapper() if wrapper: wrapper.onVariableWasChanged() def recreateInput(self, dataType): self.inp.kill() del self.inp self.inp = None self.inp = CreateRawPin('inp', self, dataType, PinDirection.Input) self.inp.disableOptions(PinOptions.RenamingEnabled) return self.inp def recreateOutput(self, dataType): self.out.kill() del self.out self.out = None self.out = CreateRawPin('out', self, dataType, PinDirection.Output) self.out.disableOptions(PinOptions.RenamingEnabled) return self.out def variableUid(self): return self.var.uid def serialize(self): default = NodeBase.serialize(self) default['varUid'] = str(self.var.uid) return default @staticmethod def category(): return PACKAGE_NAME @staticmethod def keywords(): return ["set", "var"] @staticmethod def description(): return 'Set variable value' def compute(self, *args, **kwargs): newValue = self.inp.getData() self.var.value = newValue self.out.setData(copy(self.var.value)) self.outExec.call(*args, **kwargs)
def runraw(self): sayl("#+") # called biy FreeCAD_Object createpins objname=self.objname.getData() fobj=FreeCAD.ActiveDocument.getObject(objname) if fobj == None: say("cannot create pins because no FreeCAD object for name {}".format(objname)) return [] ps=fobj.PropertiesList if 10: sayl('#') say("FreeCAD object Properties ---") for p in ps: say (p) pins=[] ipm=self.namePinInputsMap if 0: say("ipm.keys() for ",objname,fobj.Name,fobj.Label) for k in ipm.keys(): say(k) #--------------- recomputepins=[] for p in ps: say("X",p) try: a=getattr(fobj,p) except: say ("ignore problem with prop",p," fix it later !!") continue if p in ["Placement","Shape", "MapMode", "MapReversed","MapPathParameter", "Attacher", "AttacherType", "AttachmentOffset","ExpressionEngine","Support"]: pass continue if p in ipm.keys(): print("IGNORE '{}' - exists already".format(p)) continue cn=a.__class__.__name__ if p.startswith("aLink"): # zu tun continue # print("################",cn,p,a) if cn=="list" and p.endswith('List'): r2=p.replace('List','Pin') r=r2[1:] # say("--------------",p,r,r2) if r=="IntegerPin": r="IntPin" try: p1 = self.createInputPin(p, r ,[],structure=PinStructure.Array) p2 = self.createOutputPin(p+"_out", r ,[],structure=PinStructure.Array) pins += [p1,p2] except: say("cannot create list pin for",p,r2) continue if cn=="Quantity" or cn=="float": pintyp="FloatPin" elif cn=="Vector": pintyp="VectorPin" elif cn=="str" or cn=="unicode": pintyp="StringPin" elif cn=="bool": pintyp="BoolPin" elif cn=="int": pintyp="IntPin" elif cn=="Placement": pintyp="PlacementPin" elif cn=="Rotation": pintyp="RotationPin" elif cn=='list' or cn == 'dict' or cn=='tuple' or cn=='set': # zu tun continue elif cn=='Material' or cn=='Shape' or cn=='Matrix' : # zu tun continue elif cn=='NoneType' : # zu tun continue else: say(p,cn,a,"is not known") continue say("-----------------") pinname=p pinval=a say("create pin for ",pintyp,pinname,pinval) ''' if pinname not in oldpinnames: pintyp="ShapePin" p2 = CreateRawPin(pinname,self, pintyp, PinDirection.Output) try: uiPin = self.getWrapper()._createUIPinWrapper(p2) uiPin.setDisplayName("{}".format(p2.name)) except: pass self.setPinObject(pinname,subob) ''' p1 = CreateRawPin(pinname,self, pintyp, PinDirection.Input) p2 = CreateRawPin(pinname+"_out",self, pintyp, PinDirection.Output) try: uiPin = self.getWrapper()._createUIPinWrapper(p2) uiPin.setDisplayName("{}".format(p2.name)) except: pass try: uiPin = self.getWrapper()._createUIPinWrapper(p1) uiPin.setDisplayName("{}".format(p1.name)) except: pass p1.enableOptions(PinOptions.Dynamic) # p1.recomputeNode=True recomputepins += [p1] try: p1.setData(pinval) p2.setData(pinval) except: say("problem setting",p) say("created:",p1) pins += [p1,p2] sayl() for p in recomputepins: p.recomputeNode=True for p in pins: p.group="FOP" sh=fobj.Shape self.setPinObject("Shape_out",sh) return pins