def createOutputPin(self, pinName, dataType, defaultValue=None, foo=None, structure=PinStructure.Single, constraint=None, structConstraint=None, allowedPins=[]): pinName = self.getUniqPinName(pinName) p = CreateRawPin(pinName, self, dataType, PinDirection.Output) p.structureType = structure 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) 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 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
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))
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.Dict: p.initAsDict(True) elif structure == PinStructure.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 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 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
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 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 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