public IFrameModuleBase(IGraphRuntime runtime)
: base(runtime, ModuleKind.Iframe, DisplayMode.Expanded)
{
this.AddInputPin("Caption", PinDataTypeFactory.Create <string>(), PropertyMode.Always);
this.AddInputPin("SourceUri", PinDataTypeFactory.Create <string>(), PropertyMode.Always);
this.AddInputPin("Size", PinDataTypeFactory.Create <Int2>(new Int2(320, 240)), PropertyMode.Always);
}
public Take(IGraphRuntime runtime)
: base(runtime)
{
this.inputPin = AddInputPin("Input", PinDataTypeFactory.FromType(typeof(ISequence <>)), PropertyMode.Never);
this.countPin = AddInputPin("Count", PinDataTypeFactory.CreateInt32(5), PropertyMode.Default);
this.outputPin = AddOutputPin("Output", PinDataTypeFactory.FromType(typeof(ISequence <>)));
this.inputPin.WhenNodeEvent.Subscribe(evt =>
{
PinConnectionChangeEventHandler.ConnectionSensitivePinDataType(evt, PinDataTypeFactory.FromType(typeof(ISequence <>)), true, pinDataType =>
{
var genericType = pinDataType.UnderlyingType.GenericTypeArguments.FirstOrDefault();
if (genericType != null)
{
genericDelegate = new GenericDelegate <Func <object, object, object> >(this, EvaluateInternalAttribute.GetMethod(GetType()).MakeGenericMethod(genericType));
}
else
{
genericDelegate = null;
}
outputPin.ChangeType(pinDataType);
});
});
}
public PythonScriptModuleBase(IGraphRuntime runtime, ILoggerFactory loggerFactory, IPythonMainThread mainThread)
: base(runtime, ModuleKind.ScriptModule)
{
logger = loggerFactory.CreateLogger <PythonScriptModuleBase>();
this.mainThread = mainThread;
this.captionPin = this.AddInputPin("caption", PinDataTypeFactory.Create <string>(), PropertyMode.Always);
this.functionNamePin = this.AddInputPin("functionName", PinDataTypeFactory.Create <string>(DEFAULT_FUNCTION_NAME), PropertyMode.Default);
this.useMainThreadPin = this.AddInputPin("useMainThread", PinDataTypeFactory.Create <bool>(true), PropertyMode.Always);
this.parserErrorPin = this.AddInputPin("parserError", PinDataTypeFactory.Create <Models.ExceptionModel>(null, WellKnownEditors.ExceptionViewer), PropertyMode.Always);
var scriptSourcePinId = this.AddScriptSourcePin();
this.argumentPins = new List <GenericInputPin>();
this.resultPins = new List <GenericOutputPin>();
this.properties[scriptSourcePinId].WhenNodeEvent.OfType <PropertyChangedEvent>().Subscribe(evt =>
{
logger.LogInformation("Script source changed");
UpdateSignatureSafe();
});
this.properties[functionNamePin.Id].WhenNodeEvent.OfType <PropertyChangedEvent>().Subscribe(evt =>
{
logger.LogInformation("Function name changed");
UpdateSignatureSafe();
});
this.DynamicDisplayName = new DynamicDisplayNameFunc(FormatDisplayName);
}
public Broadcast(IGraphRuntime runtime)
: base(runtime)
{
this.inputPin = AddInputPin("Input", PinDataTypeFactory.FromType(typeof(ISequence <>)), PropertyMode.Never);
this.dynamicOutputPin = new DynamicOutputPin(runtime, outputs, "Output", PinDataTypeFactory.FromType(typeof(ISequence <>)));
this.inputPin.WhenNodeEvent.Subscribe(evt =>
{
PinConnectionChangeEventHandler.ConnectionSensitivePinDataType(evt, PinDataTypeFactory.FromType(typeof(ISequence <>)), true, pinDataType =>
{
var genericType = pinDataType.UnderlyingType.GenericTypeArguments.FirstOrDefault();
if (genericType != null)
{
genericDelegate = new GenericDelegate <Func <object, object[]> >(this, EvaluateInternalAttribute.GetMethod(GetType()).MakeGenericMethod(genericType));
}
else
{
genericDelegate = null;
}
foreach (var pin in dynamicOutputPin.Pins.OfType <IDataTypeChangeable>())
{
pin.ChangeType(pinDataType);
}
});
});
}
public Convert(IGraphRuntime runtime)
: base(runtime)
{
this.inputPin = AddInputPin("Input", PinDataTypeFactory.CreateFloat64(), PropertyMode.Never);
this.targetTypePin = AddInputPin("TargetType", PinDataTypeFactory.CreateEnum <ConvertTypeCode>(ConvertTypeCode.Float64), PropertyMode.Always);
this.outputPin = AddOutputPin("Output", CreateTargetPinDataType(ConvertTypeCode.Float64));
this.inputPin.WhenNodeEvent.Subscribe(evt =>
{
PinConnectionChangeEventHandler.ConnectionSensitivePinDataType(evt, CreateTargetPinDataType(ConvertTypeCode.Float64), false, pinDataType =>
{
var genericInputType = pinDataType.UnderlyingType;
BuildGenericDelegate(genericInputType, outputPin.DataType.UnderlyingType);
});
});
this.properties[targetTypePin.Id].WhenNodeEvent.OfType <PropertyChangedEvent>().Subscribe(x =>
{
var targetTypeCode = (ConvertTypeCode)x.Value.Value;
IPinDataType targetPinDataType = CreateTargetPinDataType(targetTypeCode);
var errors = outputPin.ChangeType(targetPinDataType);
if (errors.Any())
{
throw new AggregateException("One or more connections could not be reestablished after a data type change.", errors);
}
BuildGenericDelegate(inputPin.DataType.UnderlyingType, outputPin.DataType.UnderlyingType);
});
}
public Range(IGraphRuntime runtime)
: base(runtime)
{
this.startPin = AddInputPin("Start", PinDataTypeFactory.CreateInt32(0), PropertyMode.Default);
this.countPin = AddInputPin("Count", PinDataTypeFactory.CreateInt32(10), PropertyMode.Default);
this.outputPin = AddOutputPin("Output", PinDataTypeFactory.Create <ISequence <int> >());
}
public Where(IGraphRuntime runtime)
: base(runtime, false, PinDataTypeFactory.Create <bool>(), SUBGRAPH_SOURCE_PIN_ID)
{
this.inputPin = AddInputPin("Input", PinDataTypeFactory.FromType(typeof(ISequence <>)), PropertyMode.Never);
this.outputPin = AddOutputPin("Output", PinDataTypeFactory.Create <ISequence <object> >());
this.subGraphSource = ((GenericOutputPin)this.subGraphInputModule.Outputs[SUBGRAPH_SOURCE_PIN_ID]);
this.subGraphResult = this.SubGraph.OutputModule.DefaultInputPin;
this.inputPin.WhenNodeEvent.Subscribe(evt =>
{
PinConnectionChangeEventHandler.ConnectionSensitivePinDataType(evt, PinDataTypeFactory.FromType(typeof(ISequence <>)), true, pinDataType =>
{
var genericType = pinDataType.UnderlyingType.GenericTypeArguments.FirstOrDefault() ?? typeof(object);
subGraphSource.ChangeType(PinDataTypeFactory.FromType(genericType));
var outputType = PinDataTypeFactory.FromType(typeof(ISequence <>).MakeGenericType(genericType));
if (outputPin.DataType.UnderlyingType != outputType.UnderlyingType)
{
outputPin.ChangeType(outputType);
}
genericDelegate = new GenericDelegate <Func <object, object, object> >(this, EvaluateInternalAttribute.GetMethod(GetType()).MakeGenericMethod(genericType));
});
});
}
public ZipFunc(IGraphRuntime runtime)
: base(runtime)
{
this.funcPin = AddInputPin("Function", PinDataTypeFactory.Create <Delegate>(), PropertyMode.Allow);
this.dynamicInputPin = new DynamicInputPin(runtime, inputs, "Input", PinDataTypeFactory.Create <ISequence>());
this.outputPin = AddOutputPin("Output", PinDataTypeFactory.Create <ISequence <object> >());
}
public ViewCurrent(IGraphRuntime runtime)
: base(runtime, ModuleKind.ViewModule)
{
this.inputPin = AddInputPin("Input", PinDataTypeFactory.FromType(typeof(ISequence <string>), string.Empty, WellKnownEditors.Hidden, null, null), PropertyMode.Never);
this.data = AddInputPin("data", PinDataTypeFactory.CreateString(), PropertyMode.Always);
EnableVirtualOutputPin();
}
public SelectMany(IGraphRuntime runtime)
: base(runtime, false, PinDataTypeFactory.FromType(typeof(ISequence <>)), SUBGRAPH_SOURCE_PIN_ID)
{
this.inputPin = AddInputPin("Input", PinDataTypeFactory.FromType(typeof(ISequence <>)), PropertyMode.Never);
this.sequentialPin = AddInputPin("Sequential", PinDataTypeFactory.Create <bool>(true), PropertyMode.Default);
this.outputPin = AddOutputPin("Output", PinDataTypeFactory.Create <ISequence <object> >());
this.maxConcurrencyPin = AddInputPin("MaxConcurrency", PinDataTypeFactory.Create <int>(8), PropertyMode.Default);
this.subGraphSource = ((GenericOutputPin)this.subGraphInputModule.Outputs[SUBGRAPH_SOURCE_PIN_ID]);
this.subGraphResult = this.SubGraph.OutputModule.DefaultInputPin;
this.inputPin.WhenNodeEvent.Subscribe(evt =>
{
PinConnectionChangeEventHandler.ConnectionSensitivePinDataType(evt, PinDataTypeFactory.FromType(typeof(ISequence <>)), true, pinDataType =>
{
var genericType = pinDataType.UnderlyingType.GenericTypeArguments.FirstOrDefault() ?? typeof(object);
subGraphSource.ChangeType(PinDataTypeFactory.FromType(genericType));
BuildGenericDelegate();
});
});
this.subGraphResult.WhenNodeEvent.Subscribe(evt =>
{
PinConnectionChangeEventHandler.ConnectionSensitivePinDataType(evt, PinDataTypeFactory.FromType(typeof(ISequence <>)), true, pinDataType =>
{
outputPin.ChangeType(pinDataType);
BuildGenericDelegate();
});
});
}
public SequenceToArray(IGraphRuntime runtime)
: base(runtime, ModuleKind.Module, DisplayMode.Collapsed)
{
this.inputPin = AddInputPin("Sequence", PinDataTypeFactory.FromType(typeof(ISequence <>)), PropertyMode.Allow);
this.outputPin = AddOutputPin("Array", PinDataTypeFactory.FromType(typeof(object[])));
this.inputPin.WhenNodeEvent.Subscribe(evt =>
{
PinConnectionChangeEventHandler.ConnectionSensitivePinDataType(evt, PinDataTypeFactory.FromType(typeof(ISequence <>)), true, pinDataType =>
{
var method = EvaluateInternalAttribute.GetMethod(GetType()).MakeGenericMethod(pinDataType.UnderlyingType);
var genericType = pinDataType.UnderlyingType.GenericTypeArguments.FirstOrDefault() ?? pinDataType.UnderlyingType;
if (genericType != null)
{
genericDelegate = new GenericDelegate <Func <object, object> >(this, EvaluateInternalAttribute.GetMethod(GetType()).MakeGenericMethod(genericType));
}
else
{
genericDelegate = null;
}
outputPin.ChangeType(PinDataTypeFactory.FromType(genericType.MakeArrayType()));
});
});
}
private static IPinDataType CreateTargetPinDataType(ConvertTypeCode typeCode)
{
switch (typeCode)
{
case ConvertTypeCode.Any:
return(PinDataTypeFactory.Create <ISequence <object> >());
case ConvertTypeCode.Boolean:
return(PinDataTypeFactory.Create <ISequence <bool> >());
case ConvertTypeCode.Byte:
return(PinDataTypeFactory.Create <ISequence <byte> >());
case ConvertTypeCode.Int16:
return(PinDataTypeFactory.Create <ISequence <short> >());
case ConvertTypeCode.Int32:
return(PinDataTypeFactory.Create <ISequence <int> >());
case ConvertTypeCode.Int64:
return(PinDataTypeFactory.Create <ISequence <long> >());
case ConvertTypeCode.Float32:
return(PinDataTypeFactory.Create <ISequence <float> >());
case ConvertTypeCode.Float64:
return(PinDataTypeFactory.Create <ISequence <double> >());
case ConvertTypeCode.String:
return(PinDataTypeFactory.Create <ISequence <string> >());
}
return(PinDataTypeFactory.Create <object>());
}
private static IPinDataType CreateTargetPinDataType(ConvertTypeCode typeCode)
{
switch (typeCode)
{
case ConvertTypeCode.Any:
return(PinDataTypeFactory.CreateAny());;
case ConvertTypeCode.Boolean:
return(PinDataTypeFactory.CreateBoolean());
case ConvertTypeCode.Byte:
return(PinDataTypeFactory.FromType(typeof(byte)));
case ConvertTypeCode.Int16:
return(PinDataTypeFactory.FromType(typeof(short)));
case ConvertTypeCode.Int32:
return(PinDataTypeFactory.CreateInt32());
case ConvertTypeCode.Int64:
return(PinDataTypeFactory.FromType(typeof(long)));
case ConvertTypeCode.Float32:
return(PinDataTypeFactory.FromType(typeof(float)));
case ConvertTypeCode.Float64:
return(PinDataTypeFactory.FromType(typeof(double)));
case ConvertTypeCode.String:
return(PinDataTypeFactory.CreateString());
}
return(PinDataTypeFactory.Create <object>());
}
public Aggregate(IGraphRuntime runtime)
: base(runtime, false, SUBGRAPH_SOURCE_PIN_ID, SUBGRAPH_ACCUMULATE_PIN_ID)
{
this.sourceInput = AddInputPin("Source", PinDataTypeFactory.FromType(typeof(ISequence <>)), PropertyMode.Never);
this.seedInput = AddInputPin("Seed", PinDataTypeFactory.CreateAny(), PropertyMode.Allow);
this.output = AddOutputPin("Output", PinDataTypeFactory.CreateAny());
this.subGraphInput = ((GenericOutputPin)this.subGraphInputModule.Outputs[SUBGRAPH_SOURCE_PIN_ID]);
this.subGraphAccumulate = (GenericOutputPin)this.subGraphInputModule.Outputs[SUBGRAPH_ACCUMULATE_PIN_ID];
this.subGraphOutput = subGraph.OutputModule.DefaultInputPin;
this.sourceInput.WhenNodeEvent.Subscribe(evt =>
{
PinConnectionChangeEventHandler.ConnectionSensitivePinDataType(evt, PinDataTypeFactory.FromType(typeof(ISequence <>)), true, pinDataType =>
{
var genericType = pinDataType.UnderlyingType.GenericTypeArguments.FirstOrDefault() ?? typeof(object);
subGraphInput.ChangeType(PinDataTypeFactory.FromType(genericType));
BuildGenericDelegate();
});
});
this.seedInput.WhenNodeEvent.Subscribe(evt =>
{
PinConnectionChangeEventHandler.ConnectionSensitivePinDataType(evt, PinDataTypeFactory.CreateAny(), false, pinDataType =>
{
subGraphAccumulate.ChangeType(pinDataType);
output.ChangeType(pinDataType);
subGraphOutput.ChangeType(pinDataType);
BuildGenericDelegate();
});
});
}
public UnaryOperation(IGraphRuntime runtime, string moduleType, Func <double, double> operation, string resultPinName = "Result", string operandPinName = "Operand")
: base(runtime, ModuleKind.Module, DisplayMode.Expanded, moduleType)
{
this.operation = operation;
this.operandPin = this.AddInputPin(operandPinName, PinDataTypeFactory.CreateFloat64(), PropertyMode.Never);
this.resultPin = this.AddOutputPin(resultPinName, PinDataTypeFactory.CreateFloat64());
}
public SelectFunc(IGraphRuntime runtime)
: base(runtime)
{
this.inputPin = AddInputPin("Input", PinDataTypeFactory.Create <ISequence>(), PropertyMode.Never);
this.funcPin = AddInputPin("Function", PinDataTypeFactory.Create <Delegate>(), PropertyMode.Allow);
this.outputPin = AddOutputPin("Output", PinDataTypeFactory.Create <ISequence <object> >());
}
private bool OnDynamicInputAdd(string id)
{
dynamicInputPin.Pin(id).WhenNodeEvent.Subscribe(evt =>
{
PinConnectionChangeEventHandler.ConnectionSensitivePinDataType(evt, PinDataTypeFactory.FromType(typeof(ISequence <>)), true, pinDataType =>
{
var genericType = pinDataType.UnderlyingType.GenericTypeArguments.FirstOrDefault() ?? typeof(object);
var pinEvent = (PinConnectionChangeEvent)evt;
// subgraph input
var pin = SubGraph.InputModule.Outputs.Where(x => x.Id == pinEvent.Source.Id).OfType <IDataTypeChangeable>().FirstOrDefault();
pin.ChangeType(PinDataTypeFactory.FromType(genericType));
});
});
try
{
addingSubGraphPin = true;
return(SubGraph.InputModule.AddModulePin(id, true, PinDataTypeFactory.CreateAny()) != null);
}
finally
{
addingSubGraphPin = false;
}
}
private bool OnDynamicInputAdd(string id)
{
return(dynamicInputPin.Pin(id).WhenNodeEvent.Subscribe(evt =>
{
PinConnectionChangeEventHandler.ConnectionSensitivePinDataType(evt, PinDataTypeFactory.FromType(typeof(ISequence <>)), true, pinDataType =>
{
var genericType = pinDataType.UnderlyingType.GenericTypeArguments.FirstOrDefault();
if (genericType != null)
{
genericDelegate = new GenericDelegate <Func <object, object> >(this, EvaluateInternalAttribute.GetMethod(GetType()).MakeGenericMethod(genericType));
}
else
{
genericDelegate = null;
}
var pinsToChange = dynamicInputPin.Pins.Where(x => x.Id != id && x.DataType.UnderlyingType != pinDataType.UnderlyingType).OfType <IDataTypeChangeable>();
foreach (var pin in pinsToChange)
{
pin.ChangeType(pinDataType);
}
if (!pinsToChange.Any())
{
outputPin.ChangeType(pinDataType);
}
});
}) != null);
}
public Fork(IGraphRuntime runtime)
: base(runtime)
{
this.flowMode = FlowMode.WaitAny;
this.AddInputPin("flowIn", PinDataTypeFactory.CreateFlow(), PropertyMode.Never);
this.flowOutputs = new DynamicOutputPin(runtime, outputs, "Flow", PinDataTypeFactory.CreateFlow());
}
public ShaGenerator(IGraphRuntime runtime, HashAlgorithmType type)
: base(runtime)
{
this.type = type;
this.inputPin = AddInputPin("Input", PinDataTypeFactory.Create <object>(), PropertyMode.Never);
this.hashPin = AddOutputPin("Hash", PinDataTypeFactory.Create <byte[]>());
}
public GaussianRandomSequence(IGraphRuntime runtime)
: base(runtime)
{
this.seedPin = AddInputPin("Seed", PinDataTypeFactory.Create <int?>(null, WellKnownEditors.IntNumber), PropertyMode.Default);
this.muPin = AddInputPin("µ", PinDataTypeFactory.Create <double>(0, WellKnownEditors.FloatNumber), PropertyMode.Default);
this.sigmaPin = AddInputPin("σ", PinDataTypeFactory.Create <double>(1, WellKnownEditors.FloatNumber), PropertyMode.Default);
this.outputPin = AddOutputPin("Output", PinDataTypeFactory.Create <ISequence <double> >());
}
public SelectManyFunc(IGraphRuntime runtime)
: base(runtime)
{
inputPin = AddInputPin("Input", PinDataTypeFactory.Create <ISequence>(), PropertyMode.Never);
funcPin = AddInputPin("Function", PinDataTypeFactory.Create <Delegate>(), PropertyMode.Allow);
sequentialPin = AddInputPin("Sequential", PinDataTypeFactory.Create <bool>(true), PropertyMode.Default);
outputPin = AddOutputPin("Output", PinDataTypeFactory.Create <ISequence <object> >());
}
public CreateArray(IGraphRuntime runtime)
: base(runtime)
{
this.dynamicInputPin = new DynamicInputPin(runtime, inputs, "Input", PinDataTypeFactory.CreateAny(), OnDynamicInputAdd)
{
ForceAutoId = true
};
this.output = AddOutputPin("Output", PinDataTypeFactory.FromType(typeof(Array)));
}
public Merge(IGraphRuntime runtime)
: base(runtime)
{
this.dynamicInputPin = new DynamicInputPin(runtime, inputs, "Input", PinDataTypeFactory.FromType(typeof(ISequence <>)), OnDynamicInputAdd)
{
Renameable = true
};
this.outputPin = AddOutputPin("Output", PinDataTypeFactory.FromType(typeof(ISequence <>)));
}
public SequenceEqual(IGraphRuntime runtime)
: base(runtime)
{
this.firstInputPin = AddInputPin("First", PinDataTypeFactory.FromType(typeof(ISequence <>)), PropertyMode.Never);
this.secondInputPin = AddInputPin("Second", PinDataTypeFactory.FromType(typeof(ISequence <>)), PropertyMode.Never);
this.outputPin = AddOutputPin("Result", PinDataTypeFactory.CreateBoolean());
this.firstInputPin.WhenNodeEvent.Subscribe(HandleInputPinEvent);
this.secondInputPin.WhenNodeEvent.Subscribe(HandleInputPinEvent);
}
public WriteFile(IGraphRuntime runtime)
: base(runtime)
{
pathPin = this.AddInputPin("fileName", PinDataTypeFactory.Create <string>(string.Empty, WellKnownEditors.FileSelector), PropertyMode.Default, flags: PinFlags.ResolvePath);
modePin = this.AddInputPin("mode", PinDataTypeFactory.CreateEnum(WriteFileMode.OverwriteOrCreate, WellKnownEditors.DropDown), PropertyMode.Default);
writablePin = this.AddInputPin("writable", PinDataTypeFactory.Create <IWritable>(), PropertyMode.Never);
appendGuidPin = this.AddInputPin("appendGuid", PinDataTypeFactory.CreateBoolean(false), PropertyMode.Default);
createDirectoryPin = this.AddInputPin("createDirectory", PinDataTypeFactory.CreateBoolean(false), PropertyMode.Default);
EnableVirtualOutputPin();
}
public Count(IGraphRuntime runtime)
: base(runtime)
{
this.inputPin = AddInputPin("Input", PinDataTypeFactory.FromType(typeof(ISequence <>)), PropertyMode.Never);
this.outputPin = AddOutputPin("Output", PinDataTypeFactory.CreateInt32());
this.inputPin.WhenNodeEvent.Subscribe(evt =>
{
PinConnectionChangeEventHandler.ConnectionSensitivePinDataType(evt, PinDataTypeFactory.FromType(typeof(ISequence <>)), true);
});
}
public void BuildOutputPins(Type itemType)
{
if (itemType == this.itemType)
{
return;
}
// do not fall back to object when we have build pins for another type before
// (most likely the drop back to object is due to a disconnect and we do not want to loose all existing connections)
if (itemType == typeof(object) && itemPropertyPins.Count > 0)
{
return;
}
var oldConnections = new Dictionary <string, IPin[]>();
// remove all outputs
foreach (var itemPropertiesPin in itemPropertyPins)
{
oldConnections.Add(itemPropertiesPin.Id, itemPropertiesPin.Connections.Select(x => x.Remote).ToArray());
itemPropertiesPin.DisconnectAll();
outputs.Remove(itemPropertiesPin);
}
itemPropertyPins.Clear();
var itemProperties = itemType.GetProperties(BINDING_FLAGS).Where(p => p.GetIndexParameters().Length == 0);
if (itemProperties.Any())
{
// add one output pin for every property
foreach (var property in itemProperties)
{
if (this.itemPropertyPins.Any(p => p.Id == property.Name))
{
continue;
}
var pin = AddOutputPin(property.Name, PinDataTypeFactory.FromType(property.PropertyType));
this.itemPropertyPins.Add(pin);
// try to reestablish exsting connections
RestorePinConnection(pin, oldConnections);
}
}
else
{
// add a single pin for items without properties
this.itemPropertyPins.Add(AddOutputPin(itemType.Name, PinDataTypeFactory.FromType(itemType)));
}
// store current type in property
this.ItemTypeName = itemType.AssemblyQualifiedName;
this.itemType = itemType;
}
public Join(IGraphRuntime runtime)
: base(runtime)
{
this.flowMode = FlowMode.WaitAllOrFirstException;
this.flowInputs = new DynamicInputPin(runtime, inputs, "Flow", PinDataTypeFactory.CreateFlow())
{
MaxConnections = null,
ForceAutoId = true
};
this.flowOut = this.AddOutputPin("flowOut", PinDataTypeFactory.CreateFlow(), 1);
}
public ForLoop(IGraphRuntime runtime)
: base(runtime, false, (IPinDataType)null)
{
subGraph.InputModule.AddModulePin(SUBGRAPH_INDEX_PIN_ID, false, PinDataTypeFactory.CreateInt32());
subGraph.OutputModule.AddModulePin("Break", PinDataTypeFactory.CreateFlow(), PinFlags.None, null);
this.AddInputPin("startValue", PinDataTypeFactory.CreateInt32(0), PropertyMode.Default); // Initial value for counting
this.AddInputPin("increment", PinDataTypeFactory.CreateInt32(1), PropertyMode.Default); // Inrement of the counter variable after each evaluation of the loop body.
this.AddInputPin("endValue", PinDataTypeFactory.CreateInt32(100), PropertyMode.Default); // Exit loop when the counter variable becomes greater or equal to this value.
this.DynamicDisplayName = new DynamicDisplayNameFunc(FormatDisplayName);
}
