/// <summary>
/// Registers all the input parameters for this component.
/// </summary>
protected override void RegisterInputParams(GH_Component.GH_InputParamManager pManager)
{
pManager.AddGenericParameter("Bitmap", "B", "---", GH_ParamAccess.item);
pManager[0].Optional = true;
Param_GenericObject paramGen = (Param_GenericObject)Params.Input[0];
paramGen.PersistentData.Append(new GH_ObjectWrapper(new Bitmap(100, 100)));
pManager.AddIntegerParameter("Mode", "M", "---", GH_ParamAccess.item, 0);
pManager[1].Optional = true;
pManager.AddNumberParameter("Red", "R", "---", GH_ParamAccess.item, 0.2125);
pManager[2].Optional = true;
pManager.AddNumberParameter("Green", "G", "---", GH_ParamAccess.item, 0.7154);
pManager[3].Optional = true;
pManager.AddNumberParameter("Blue", "B", "---", GH_ParamAccess.item, 0.0721);
pManager[4].Optional = true;
Param_Integer param = (Param_Integer)Params.Input[1];
param.AddNamedValue(modes[0], 0);
param.AddNamedValue(modes[1], 1);
param.AddNamedValue(modes[2], 2);
param.AddNamedValue(modes[3], 3);
}
public void diffStructure(List <SpeckleLayer> newLayers)
{
dynamic diffResult = SpeckleLayer.diffLayers(getLayers(), newLayers);
foreach (SpeckleLayer layer in diffResult.toRemove)
{
var myparam = Params.Output.FirstOrDefault(item => { return(item.Name == layer.guid); });
if (myparam != null)
{
Params.UnregisterOutputParameter(myparam);
}
}
foreach (var layer in diffResult.toAdd)
{
Param_GenericObject newParam = getGhParameter(layer);
Params.RegisterOutputParam(newParam, layer.orderIndex);
}
foreach (var layer in diffResult.toUpdate)
{
var myparam = Params.Output.FirstOrDefault(item => { return(item.Name == layer.guid); });
myparam.NickName = layer.name;
}
Params.OnParametersChanged();
}
public void UpdateInputs()
{
// Unregister input parameter
while (Params.Input.Count() > 1)
{
Params.UnregisterInputParameter(Params.Input.First(i => i.Name != "SpeckleObject"));
}
// Add input parameters
IEnumerable <PropertyInfo> props = ObjectType.GetProperties().Where(p => p.CanWrite);
if (!ExposeAllProperties)
{
props = props.Where(p => !typeof(SpeckleObject).GetProperties().Any(s => s.Name == p.Name));
}
foreach (PropertyInfo p in props)
{
Param_GenericObject newParam = new Param_GenericObject();
newParam.Name = (string)p.Name;
newParam.NickName = (string)p.Name;
newParam.MutableNickName = false;
newParam.Access = GH_ParamAccess.item;
newParam.Optional = true;
newParam.ObjectChanged += (sender, e) => Debouncer.Start();
Params.RegisterInputParam(newParam);
}
Params.OnParametersChanged();
}
public IGH_Param CreateParameter(GH_ParameterSide side, int index)
{
// if remoteFly
if (index == this.Params.Input.Count)
{
this._remoteFly = true;
}
if (this._remoteFly && (index == this.Params.Input.Count))
{
var remoteInParam = new Param_Boolean();
var remoteOutParam = new Param_Boolean();
Params.RegisterOutputParam(remoteOutParam, index);
return(remoteInParam);
}
// add normal params
var outParam = new Param_GenericObject();
outParam.NickName = String.Empty;
Params.RegisterOutputParam(outParam, index);
var inParam = new Param_GenericObject();
inParam.NickName = String.Empty;
return(inParam);
}
public void UpdateOutputStructure( )
{
//TODO: Check if we're out or under range, and add default layers as such.
List <Layer> toRemove, toAdd, toUpdate;
toRemove = new List <Layer>(); toAdd = new List <Layer>(); toUpdate = new List <Layer>();
Layer.DiffLayerLists(GetLayers(), Layers, ref toRemove, ref toAdd, ref toUpdate);
foreach (Layer layer in toRemove)
{
var myparam = Params.Output.FirstOrDefault(item => { return(item.Name == layer.Guid); });
if (myparam != null)
{
Params.UnregisterOutputParameter(myparam);
}
}
int k = 0;
foreach (var layer in toAdd)
{
Param_GenericObject newParam = getGhParameter(layer);
Params.RegisterOutputParam(newParam, layer.OrderIndex != null ? ( int )layer.OrderIndex : k);
k++;
}
foreach (var layer in toUpdate)
{
var myparam = Params.Output.FirstOrDefault(item => { return(item.Name == layer.Guid); });
myparam.NickName = layer.Name;
}
Params.OnParametersChanged();
}
/// <summary>
/// Registers all the input parameters for this component.
/// </summary>
protected override void RegisterInputParams(GH_Component.GH_InputParamManager pManager)
{
pManager.AddGenericParameter("Object", "O", "Wind Objects", GH_ParamAccess.item);
pManager.AddIntegerParameter("Pattern", "P", "Pattern", GH_ParamAccess.item, 0);
pManager[1].Optional = true;
pManager.AddNumberParameter("Scale", "S", "Scale", GH_ParamAccess.item, 1);
pManager[2].Optional = true;
pManager.AddColourParameter("Fore", "F", "---", GH_ParamAccess.item, wColors.LightGray.ToDrawingColor());
pManager[3].Optional = true;
pManager.AddColourParameter("Back", "B", "---", GH_ParamAccess.item, wColors.VeryLightGray.ToDrawingColor());
pManager[4].Optional = true;
Param_GenericObject paramGen = (Param_GenericObject)Params.Input[0];
paramGen.PersistentData.Append(new GH_ObjectWrapper(new pSpacer(new GUIDtoAlpha(Convert.ToString(this.Attributes.InstanceGuid.ToString() + Convert.ToString(this.RunCount)), false).Text)));
Param_Integer param = (Param_Integer)pManager[1];
param.AddNamedValue("Grid", 0);
param.AddNamedValue("Diamond", 1);
param.AddNamedValue("Triangular", 2);
param.AddNamedValue("Hexagonal", 3);
param.AddNamedValue("Stagger", 4);
param.AddNamedValue("Checker", 5);
param.AddNamedValue("Solid Diamond", 6);
param.AddNamedValue("Trellis", 7);
param.AddNamedValue("Dots", 8);
}
/// <summary>
/// Registers all the input parameters for this component.
/// </summary>
protected override void RegisterInputParams(GH_Component.GH_InputParamManager pManager)
{
pManager.AddTextParameter("Viewport Name", "N", "---", GH_ParamAccess.item, "GH_HACK");
pManager[0].Optional = true;
pManager.AddIntegerParameter("Display", "D", "---", GH_ParamAccess.item, 0);
pManager[1].Optional = true;
pManager.AddIntegerParameter("Projection", "P", "---", GH_ParamAccess.item, 0);
pManager[2].Optional = true;
pManager.AddGenericParameter("Camera", "C", "---", GH_ParamAccess.item);
pManager[3].Optional = true;
Param_Integer param = (Param_Integer)pManager[2];
param.AddNamedValue("Parallel", 0);
param.AddNamedValue("Perspective", 1);
param.AddNamedValue("Two Point", 2);
Param_GenericObject paramGen = (Param_GenericObject)Params.Input[3];
paramGen.PersistentData.Append(new GH_ObjectWrapper(new wCameraStandard()));
SetDisplayMode();
}
/// <summary>
/// Registers all the input parameters for this component.
/// </summary>
protected override void RegisterInputParams(GH_Component.GH_InputParamManager pManager)
{
pManager.AddGenericParameter("Bitmap", "B", "---", GH_ParamAccess.item);
pManager[0].Optional = true;
Param_GenericObject paramGen = (Param_GenericObject)Params.Input[0];
paramGen.SetPersistentData(new Bitmap(10, 10));
pManager.AddIntegerParameter("Mode", "M", "...", GH_ParamAccess.item, 0);
pManager[1].Optional = true;
pManager.AddNumberParameter("Offset", "O", "...", GH_ParamAccess.item, 0);
pManager[2].Optional = true;
pManager.AddNumberParameter("Depth", "D", "...", GH_ParamAccess.item, 1);
pManager[3].Optional = true;
pManager.AddIntegerParameter("Width", "W", "...", GH_ParamAccess.item, 600);
pManager[4].Optional = true;
pManager.AddIntegerParameter("Height", "H", "...", GH_ParamAccess.item, 600);
pManager[5].Optional = true;
Param_Integer param = (Param_Integer)Params.Input[1];
param.AddNamedValue(modes[0], 0);
param.AddNamedValue(modes[1], 1);
}
/// <summary>
/// Registers all the input parameters for this component.
/// </summary>
protected override void RegisterInputParams(GH_Component.GH_InputParamManager pManager)
{
pManager.AddGenericParameter("Source Bitmap", "B", "---", GH_ParamAccess.item);
pManager[0].Optional = true;
Param_GenericObject paramGen = (Param_GenericObject)Params.Input[0];
paramGen.SetPersistentData(new Bitmap(10, 10));
pManager.AddGenericParameter("Target Bitmap", "T", "---", GH_ParamAccess.item);
pManager[0].Optional = true;
Param_GenericObject paramGenA = (Param_GenericObject)Params.Input[1];
paramGenA.SetPersistentData(new Bitmap(10, 10));
pManager.AddIntegerParameter("Mode", "M", "...", GH_ParamAccess.item, 0);
pManager[2].Optional = true;
Param_Integer paramA = (Param_Integer)Params.Input[2];
paramA.AddNamedValue("Crop", 0);
paramA.AddNamedValue("Fit", 1);
paramA.AddNamedValue("Stretch", 2);
}
public override void AddedToDocument(GH_Document document)
{
base.AddedToDocument(document);
ExpireComponent = () => this.ExpireSolution(true);
setInputsAndExpireComponent = () =>
{
for (int i = Params.Output.Count - 1; i >= 0; i--)
{
var myParam = Params.Output[i];
if ((!Global.Keys.Contains(myParam.Name)) || (!Global.Keys.Contains(myParam.NickName)))
{
Params.UnregisterOutputParameter(myParam, true);
}
}
Params.OnParametersChanged();
foreach (var key in Global.Keys)
{
var myparam = Params.Output.FirstOrDefault(q => q.Name == key);
if (myparam == null)
{
Param_GenericObject newParam = getGhParameter(key);
Params.RegisterOutputParam(newParam);
}
}
Params.OnParametersChanged();
//end
this.ExpireSolution(true);
};
}
IGH_Param ConstructVariable(GH_VarParamSide side, string nickname)
{
if (side == GH_VarParamSide.Input)
{
var param = new Param_ScriptVariable();
if (!string.IsNullOrWhiteSpace(nickname))
{
param.NickName = nickname;
}
FixGhInput(param);
return(param);
}
if (side == GH_VarParamSide.Output)
{
var param = new Param_GenericObject();
if (string.IsNullOrWhiteSpace(nickname))
{
param.Name = param.NickName;
}
else
{
param.NickName = nickname;
param.Name = String.Format("Result {0}", nickname);
}
param.Description = String.Format("Output parameter {0}", param.NickName);
return(param);
}
return(null);
}
/// <summary>
/// Adds a property to the component's inputs.
/// </summary>
/// <param name="prop"></param>
void RegisterPropertyAsInputParameter(PropertyInfo prop, int index)
{
// get property name and value
Type propType = prop.PropertyType;
string propName = prop.Name;
object propValue = prop;
// Create new param based on property name
Param_GenericObject newInputParam = new Param_GenericObject();
newInputParam.Name = propName;
newInputParam.NickName = propName;
newInputParam.MutableNickName = false;
newInputParam.Description = propName + " as " + propType.Name;
newInputParam.Optional = true;
// check if input needs to be a list or item access
bool isCollection = typeof(System.Collections.IEnumerable).IsAssignableFrom(propType) && propType != typeof(string);
if (isCollection == true)
{
newInputParam.Access = GH_ParamAccess.list;
}
else
{
newInputParam.Access = GH_ParamAccess.item;
}
Params.RegisterInputParam(newInputParam, index);
}
private void AddToOutput(IGH_DataAccess DA, string name, DataTree <object> data)
{
var index = 0;
var found = false;
foreach (var param in Params.Output)
{
if (param.Name == name)
{
found = true;
break;
}
index++;
}
if (!found)
{
var p = new Param_GenericObject
{
Name = name,
NickName = name,
Access = GH_ParamAccess.tree
};
Params.RegisterOutputParam(p);
Params.OnParametersChanged();
ExpireSolution(true);
}
else
{
DA.SetDataTree(index, data);
}
}
/// <summary>
/// Registers all the input parameters for this component.
/// </summary>
protected override void RegisterInputParams(GH_Component.GH_InputParamManager pManager)
{
pManager.AddGenericParameter("Bitmap", "B", "---", GH_ParamAccess.item);
pManager[0].Optional = true;
Param_GenericObject paramGen = (Param_GenericObject)Params.Input[0];
paramGen.PersistentData.Append(new GH_ObjectWrapper(new Bitmap(100, 100)));
pManager.AddIntegerParameter("Mode", "M", "---", GH_ParamAccess.item, 0);
pManager[1].Optional = true;
pManager.AddColourParameter("Target", "T", "...", GH_ParamAccess.item, System.Drawing.Color.Red);
pManager[2].Optional = true;
pManager.AddColourParameter("Fill", "F", "...", GH_ParamAccess.item, System.Drawing.Color.Black);
pManager[3].Optional = true;
pManager.AddIntegerParameter("Tolerance", "P", "...", GH_ParamAccess.item, 10);
pManager[4].Optional = true;
pManager.AddPointParameter("Location", "L", "...", GH_ParamAccess.item, new Point3d(1, 1, 0));
pManager[5].Optional = true;
Param_Integer param = (Param_Integer)Params.Input[1];
param.AddNamedValue(modes[0], 0);
param.AddNamedValue(modes[1], 1);
}
public void UpdateOutputStructure( )
{
List <SpeckleLayer> toRemove, toAdd, toUpdate;
toRemove = new List <SpeckleLayer>(); toAdd = new List <SpeckleLayer>(); toUpdate = new List <SpeckleLayer>();
SpeckleLayer.DiffLayerLists(GetLayers(), Layers, ref toRemove, ref toAdd, ref toUpdate);
foreach (SpeckleLayer layer in toRemove)
{
var myparam = Params.Output.FirstOrDefault(item => { return(item.Name == layer.Guid); });
if (myparam != null)
{
Params.UnregisterOutputParameter(myparam);
}
}
foreach (var layer in toAdd)
{
Param_GenericObject newParam = getGhParameter(layer);
Params.RegisterOutputParam(newParam, ( int )layer.OrderIndex);
}
foreach (var layer in toUpdate)
{
var myparam = Params.Output.FirstOrDefault(item => { return(item.Name == layer.Guid); });
myparam.NickName = layer.Name;
}
Params.OnParametersChanged();
}
public IGH_Param CreateParameter(GH_ParameterSide side, int index)
{
Param_GenericObject input = new Param_GenericObject();
Params.RegisterInputParam(input, index);
return(input);
}
/// <summary>
/// Adds a property to the component's inputs.
/// </summary>
/// <param name="param"></param>
private void RegisterPropertyAsInputParameter(ParameterInfo param, int index)
{
// get property name and value
Type propType = param.ParameterType;
if (propType.IsGenericType && propType.GetGenericTypeDefinition() == typeof(Nullable<>))
propType = Nullable.GetUnderlyingType(propType);
string propName = param.Name;
object propValue = param;
var inputDesc = param.GetCustomAttribute<SchemaParamInfo>();
var d = inputDesc != null ? inputDesc.Description : "";
if (param.IsOptional)
{
if (!string.IsNullOrEmpty(d))
d += ", ";
var def = param.DefaultValue == null ? "null" : param.DefaultValue.ToString();
d += "default = " + def;
}
// Create new param based on property name
Param_GenericObject newInputParam = new Param_GenericObject();
newInputParam.Name = propName;
newInputParam.NickName = propName;
newInputParam.MutableNickName = false;
newInputParam.Description = $"({propType.Name}) {d}";
newInputParam.Optional = param.IsOptional;
if (param.IsOptional)
newInputParam.SetPersistentData(param.DefaultValue);
// check if input needs to be a list or item access
bool isCollection = typeof(System.Collections.IEnumerable).IsAssignableFrom(propType) &&
propType != typeof(string) && !propType.Name.ToLower().Contains("dictionary");
if (isCollection == true)
{
newInputParam.Access = GH_ParamAccess.list;
}
else
{
newInputParam.Access = GH_ParamAccess.item;
}
Params.RegisterInputParam(newInputParam, index);
//add dropdown
if (propType.IsEnum)
{
//expire solution so that node gets proper size
ExpireSolution(true);
var instance = Activator.CreateInstance(propType);
var vals = Enum.GetValues(propType).Cast<Enum>().Select(x => x.ToString()).ToList();
var options = CreateDropDown(propName, vals, Attributes.Bounds.X, Params.Input[index].Attributes.Bounds.Y);
_document.AddObject(options, false);
Params.Input[index].AddSource(options);
}
}
/// <summary>
/// Registers all the input parameters for this component.
/// </summary>
protected override void RegisterInputParams(GH_Component.GH_InputParamManager pManager)
{
pManager.AddGenericParameter("Object", "O", "Updated Wind Object", GH_ParamAccess.item);
Param_GenericObject paramGen = (Param_GenericObject)Params.Input[0];
paramGen.PersistentData.Append(new GH_ObjectWrapper(new pSpacer(new GUIDtoAlpha(Convert.ToString(this.Attributes.InstanceGuid.ToString() + Convert.ToString(this.RunCount)), false).Text)));
}
/// <summary>
/// Registers all the input parameters for this component.
/// </summary>
protected override void RegisterInputParams(GH_Component.GH_InputParamManager pManager)
{
pManager.AddGenericParameter("Bitmap", "B", "---", GH_ParamAccess.item);
pManager[0].Optional = true;
Param_GenericObject paramGen = (Param_GenericObject)Params.Input[0];
paramGen.SetPersistentData(new Bitmap(10, 10));
pManager.AddIntegerParameter("Alpha", "Ac", "...", GH_ParamAccess.item, 0);
pManager[1].Optional = true;
pManager.AddIntegerParameter("Red", "Rc", "...", GH_ParamAccess.item, 1);
pManager[2].Optional = true;
pManager.AddIntegerParameter("Green", "Gc", "...", GH_ParamAccess.item, 2);
pManager[3].Optional = true;
pManager.AddIntegerParameter("Blue", "Bc", "...", GH_ParamAccess.item, 3);
pManager[4].Optional = true;
Param_Integer paramA = (Param_Integer)Params.Input[1];
paramA.AddNamedValue(modes[0], 0);
paramA.AddNamedValue(modes[1], 1);
paramA.AddNamedValue(modes[2], 2);
paramA.AddNamedValue(modes[3], 3);
paramA.AddNamedValue(modes[4], 4);
paramA.AddNamedValue(modes[5], 5);
paramA.AddNamedValue(modes[6], 6);
Param_Integer paramR = (Param_Integer)Params.Input[2];
paramR.AddNamedValue(modes[0], 0);
paramR.AddNamedValue(modes[1], 1);
paramR.AddNamedValue(modes[2], 2);
paramR.AddNamedValue(modes[3], 3);
paramR.AddNamedValue(modes[4], 4);
paramR.AddNamedValue(modes[5], 5);
paramR.AddNamedValue(modes[6], 6);
Param_Integer paramG = (Param_Integer)Params.Input[3];
paramG.AddNamedValue(modes[0], 0);
paramG.AddNamedValue(modes[1], 1);
paramG.AddNamedValue(modes[2], 2);
paramG.AddNamedValue(modes[3], 3);
paramG.AddNamedValue(modes[4], 4);
paramG.AddNamedValue(modes[5], 5);
paramG.AddNamedValue(modes[6], 6);
Param_Integer paramB = (Param_Integer)Params.Input[4];
paramB.AddNamedValue(modes[0], 0);
paramB.AddNamedValue(modes[1], 1);
paramB.AddNamedValue(modes[2], 2);
paramB.AddNamedValue(modes[3], 3);
paramB.AddNamedValue(modes[4], 4);
paramB.AddNamedValue(modes[5], 5);
paramB.AddNamedValue(modes[6], 6);
}
/// <summary>
/// Registers all the input parameters for this component.
/// </summary>
protected override void RegisterInputParams(GH_Component.GH_InputParamManager pManager)
{
pManager.AddGenericParameter("Bitmap", "B", "---", GH_ParamAccess.item);
pManager[0].Optional = true;
Param_GenericObject paramGen = (Param_GenericObject)Params.Input[0];
paramGen.SetPersistentData(new Bitmap(10, 10));
}
public IGH_Param CreateParameter(GH_ParameterSide side, int index)
{
Param_GenericObject output = new Param_GenericObject();
Params.RegisterOutputParam(output, index);
//param.Name = GH_ComponentParamServer.InventUniqueNickname("ABCDEFGHIJKLMNOPQRSTUVWXYZ", Params.Input);
output.NickName = string.Empty;
//param.Description = "Param" + (Params.Input.Count + 1);
return(output);
}
//SET MATERIALS
public void UpdateMaterial(int index)
{
Param_GenericObject paramGen = (Param_GenericObject)Params.Input[index];
paramGen.PersistentData.ClearData();
paramGen.PersistentData.Append(new GH_ObjectWrapper(Shader));
Params.Input[index].ClearData();
Params.Input[index].AddVolatileData(new Grasshopper.Kernel.Data.GH_Path(0), 0, Shader);
}
/// <summary>
/// Registers all the input parameters for this component.
/// </summary>
protected override void RegisterInputParams(GH_Component.GH_InputParamManager pManager)
{
pManager.AddGenericParameter("Object", "O", "Wind Objects", GH_ParamAccess.item);
pManager.AddColourParameter("Color", "C", "---", GH_ParamAccess.item, wColors.VeryLightGray.ToDrawingColor());
pManager[1].Optional = true;
Param_GenericObject paramGen = (Param_GenericObject)Params.Input[0];
paramGen.PersistentData.Append(new GH_ObjectWrapper(new pSpacer(new GUIDtoAlpha(Convert.ToString(this.Attributes.InstanceGuid.ToString() + Convert.ToString(this.RunCount)), false).Text)));
}
IGH_Param IGH_VariableParameterComponent.CreateParameter(GH_ParameterSide side, int index)
{
Param_GenericObject param = new Param_GenericObject();
param.Name = GH_ComponentParamServer.InventUniqueNickname("ABCDEFGHIJKLMNOPQRSTUVWXYZ", Params.Input);
param.NickName = param.Name;
param.Description = "Param" + (Params.Input.Count + 1);
return(param);
}
private Param_GenericObject getGhParameter(SpeckleLayer param)
{
Param_GenericObject newParam = new Param_GenericObject();
newParam.Name = ( string )param.Guid;
newParam.NickName = ( string )param.Name;
newParam.MutableNickName = false;
newParam.Access = GH_ParamAccess.tree;
return(newParam);
}
private Param_GenericObject getGhParameter(string key)
{
Param_GenericObject newParam = new Param_GenericObject();
newParam.Name = (string)key;
newParam.NickName = (string)key;
newParam.MutableNickName = false;
newParam.Access = GH_ParamAccess.list;
return(newParam);
}
public void SetIO( )
{
if (selectedMethod == null)
{
return;
}
this.Name = this.NickName = selectedMethod.name;
foreach (var param in Params.Input.ToArray())
{
Params.UnregisterParameter(param);
//Params.UnregisterInputParameter( param );
}
foreach (var param in Params.Output.ToArray())
{
Params.UnregisterParameter(param);
//Params.UnregisterOutputParameter( param );
}
foreach (var inp in selectedMethod.inputs)
{
Param_GenericObject newParam = new Param_GenericObject();
newParam.NickName = string.Format("{0}", inp.name);
newParam.Name = string.Format("{0} ({1})", inp.name, inp.type);
if (!inp.isOptional)
{
newParam.Optional = false;
}
if (inp.type.Contains("numerable"))
{
newParam.Name += " (List)";
}
newParam.Access = GH_ParamAccess.list;
Params.RegisterInputParam(newParam);
}
foreach (var inp in selectedMethod.outputs)
{
Param_GenericObject newParam = new Param_GenericObject();
newParam.NickName = string.Format("{0}", inp.name);
newParam.Name = string.Format("{0} ({1})", inp.name, inp.type);
newParam.Access = GH_ParamAccess.list;
Params.RegisterOutputParam(newParam);
}
Params.OnParametersChanged();
}
/// <summary>
/// Adds to the default deserialization method to retrieve the saved child status so it persists on copy/paste and save/reopen.
/// </summary>
public override bool Read(GH_IReader reader)
{
ModeIndex = reader.GetInt32("ModeIndex");
Param_GenericObject paramGen = (Param_GenericObject)Params.Input[0];
paramGen.SetPersistentData(new Bitmap(10, 10));
UpdateMessage();
return(base.Read(reader));
}
public IGH_Param CreateParameter(GH_ParameterSide side, int index, bool is_twin)
{
switch (side)
{
case GH_ParameterSide.Input:
return(new Param_ScriptVariable
{
NickName = GH_ComponentParamServer.InventUniqueNickname("xyzuvwst", this.Params.Input),
Name = NickName,
Description = "Script variable " + NickName,
Access = GH_ParamAccess.item,
AllowTreeAccess = false,
});
case GH_ParameterSide.Output:
IGH_Param p;
if (!is_twin)
{
if (used_script_variable_names == null)
{
used_script_variable_names = new List <string>();
script_variables_in_use = new List <string>();
}
string script_variable = GH_ComponentParamServer.InventUniqueNickname("abcdefghijklmn", used_script_variable_names);
used_script_variable_names.Add(script_variable);
Param_GenericObject geom = new Param_GenericObject();
geom.NickName = script_variable;
geom.Name = NickName;
geom.Description = "Contains the translated geometry found in outie " + script_variable;
p = geom;
}
else
{
if (Params.Output.Count <= 1)
{
return(null);
}
string nickname = AttNicknameFromGeomNickname(Params.Output[index - 1].NickName);
//Param_String prop = new Param_String();
GHParam_Decodes_Attributes prop = new GHParam_Decodes_Attributes();
prop.NickName = nickname;
prop.Name = nickname;
prop.Description = "Contains the non-geometric properties of the geometry found in the parameter above";
prop.MutableNickName = false;
p = prop;
}
return(p);
default: {
return(null);
}
}
}
/// <summary>
/// Registers all the input parameters for this component.
/// </summary>
protected override void RegisterInputParams(GH_Component.GH_InputParamManager pManager)
{
Param_GenericObject parameter = new Param_GenericObject();
parameter.Name = "Pipe Input";
parameter.NickName = "pipe_name_" + Convert.ToBase64String(Guid.NewGuid().ToByteArray());
parameter.Description = "Input for the pipe.";
parameter.Access = GH_ParamAccess.list;
parameter.DataMapping = GH_DataMapping.Flatten;
pManager.AddParameter(parameter);
}
IGH_Param IGH_VariableParameterComponent.CreateParameter(GH_ParameterSide side, int index)
{
Param_GenericObject param = new Param_GenericObject();
/* param.Name = GH_ComponentParamServer.InventUniqueNickname("ABCDEFGHIJKLMNOPQRSTUVWXYZ", Params.Input);
param.NickName = param.Name;
param.Description = "Param" + (Params.Input.Count + 1);
param.SetPersistentData(0.0); */
return param;
}
IGH_Param ConstructVariable(GH_VarParamSide side, string nickname)
{
if (side == GH_VarParamSide.Input)
{
var param = new Param_ScriptVariable();
if (!string.IsNullOrWhiteSpace(nickname))
param.NickName = nickname;
FixGhInput(param);
return param;
}
if (side == GH_VarParamSide.Output)
{
var param = new Param_GenericObject();
if (string.IsNullOrWhiteSpace(nickname))
param.Name = param.NickName;
else
{
param.NickName = nickname;
param.Name = String.Format("Result {0}", nickname);
}
param.Description = String.Format("Output parameter {0}", param.NickName);
return param;
}
return null;
}
