private int ComputeW_ico(IGH_Component owner) { GH_SwitcherComponent gH_SwitcherComponent = (GH_SwitcherComponent)owner; int num = 24; int num2 = 0; int num3 = 0; foreach (IGH_Param componentInput in gH_SwitcherComponent.StaticData.GetComponentInputs()) { int val = ((List <IGH_StateTag>)componentInput.StateTags).Count * 20; num3 = Math.Max(num3, val); num2 = Math.Max(num2, GH_FontServer.StringWidth(componentInput.NickName, StandardFont.font())); } num2 = Math.Max(num2 + 6, 12); num2 += num3; int num4 = 0; int num5 = 0; foreach (IGH_Param componentOutput in gH_SwitcherComponent.StaticData.GetComponentOutputs()) { int val2 = ((List <IGH_StateTag>)componentOutput.StateTags).Count * 20; num5 = Math.Max(num5, val2); num4 = Math.Max(num4, GH_FontServer.StringWidth(componentOutput.NickName, StandardFont.font())); } num4 = Math.Max(num4 + 6, 12); num4 += num5; return(num2 + num + num4 + 6); }
public static bool GetDataOrDefault(IGH_Component component, IGH_DataAccess DA, string name, out DB.Document document) { document = default; var _Document_ = component.Params.IndexOfInputParam(name); if (_Document_ < 0) { document = Revit.ActiveDBDocument; if (document?.IsValidObject != true) { component.AddRuntimeMessage(GH_RuntimeMessageLevel.Warning, "There is no active Revit document"); return(false); } // In case the user has more than one document open we show which one this component is working on if (Revit.ActiveDBApplication.Documents.Size > 1) { component.Message = document.Title.TripleDot(16); } } else { document = default; DA.GetData(_Document_, ref document); if (document?.IsValidObject != true) { component.AddRuntimeMessage(GH_RuntimeMessageLevel.Warning, "Input parameter Document failed to collect data"); return(false); } } return(true); }
/// <summary> /// Generates selection list for cell oritentation. /// </summary> /// <param name="index">Component input index. (first input is index 0)</param> /// <param name="offset">Vertical offset of the menu, to help with positioning.</param> public static void OrientSelect(ref IGH_Component Component, ref GH_Document GrasshopperDocument, int index, float offset) { // Instantiate new value list var vallist = new Grasshopper.Kernel.Special.GH_ValueList(); vallist.ListMode = Grasshopper.Kernel.Special.GH_ValueListMode.Cycle; vallist.CreateAttributes(); // Customise value list position float xCoord = (float)Component.Attributes.Pivot.X - 200; float yCoord = (float)Component.Attributes.Pivot.Y + index * 40 - offset; PointF cornerPt = new PointF(xCoord, yCoord); vallist.Attributes.Pivot = cornerPt; // Populate value list with our own data vallist.ListItems.Clear(); var items = new List<Grasshopper.Kernel.Special.GH_ValueListItem>(); items.Add(new Grasshopper.Kernel.Special.GH_ValueListItem("Default", "0")); items.Add(new Grasshopper.Kernel.Special.GH_ValueListItem("RotateZ", "1")); items.Add(new Grasshopper.Kernel.Special.GH_ValueListItem("RotateY", "2")); items.Add(new Grasshopper.Kernel.Special.GH_ValueListItem("RotateX", "3")); vallist.ListItems.AddRange(items); // Until now, the slider is a hypothetical object. // This command makes it 'real' and adds it to the canvas. GrasshopperDocument.AddObject(vallist, false); //Connect the new slider to this component Component.Params.Input[index].AddSource(vallist); Component.Params.Input[index].CollectData(); }
// The function that takes out the params from the source and target objects // it finds out which components are sources and targets and which node to connect them to. private List <IGH_Param> getParams(List <IGH_DocumentObject> g, int index, int counter, bool isInput) { List <IGH_Param> pList = new List <IGH_Param>(); for (int i = -1; i < index; i++) /*for loop*/ { foreach (IGH_DocumentObject o in g) { if (o is IGH_Component) { IGH_Component p = o as IGH_Component; if (isInput) { pList.Add(p.Params.Input[index]); /*i instead for index*/ } else if (i != index - 1) { pList.Add(p.Params.Output[i + 1 + counter]); } } else { IGH_Param p = o as IGH_Param; pList.Add(p); } } } return(pList); }
public static void AddOutputs(this IGH_Component gH_Component, int[] indexes, IGH_Param[] outputParams) { foreach (int index in indexes) { IGH_Param parameter = outputParams[index]; if (gH_Component.Params.Output.Any(x => x.Name == parameter.Name)) { gH_Component.Params.UnregisterOutputParameter(gH_Component.Params.Output.First(x => x.Name == parameter.Name), true); } else { int insertIndex = gH_Component.Params.Output.Count; for (int i = 0; i < gH_Component.Params.Output.Count; i++) { int otherIndex = Array.FindIndex(outputParams, x => x.Name == gH_Component.Params.Output[i].Name); if (otherIndex > index) { insertIndex = i; break; } } gH_Component.Params.RegisterOutputParam(parameter, insertIndex); } gH_Component.Params.OnParametersChanged(); } gH_Component.ExpireSolution(true); }
public static void ExpireOutput(this IGH_Component component, int output) { foreach (var receiver in component.Params.Output[output].Recipients) { receiver.ExpireSolution(true); } }
public static void ExpireOutputs(this IGH_Component component, params int[] outputs) { foreach (var output in outputs) { component.ExpireOutput(output); } }
public static void ExpireOutputs(this IGH_Component component, IEnumerable <int> outputs) { foreach (var output in outputs) { component.ExpireOutput(output); } }
/// <summary> /// Generates selection list for cell oritentation. /// </summary> /// <param name="index">Component input index. (first input is index 0)</param> /// <param name="offset">Vertical offset of the menu, to help with positioning.</param> public static void OrientSelect(ref IGH_Component Component, ref GH_Document GrasshopperDocument, int index, float offset) { // Instantiate new value list var vallist = new Grasshopper.Kernel.Special.GH_ValueList(); vallist.ListMode = Grasshopper.Kernel.Special.GH_ValueListMode.Cycle; vallist.CreateAttributes(); // Customise value list position float xCoord = (float)Component.Attributes.Pivot.X - 200; float yCoord = (float)Component.Attributes.Pivot.Y + index * 40 - offset; PointF cornerPt = new PointF(xCoord, yCoord); vallist.Attributes.Pivot = cornerPt; // Populate value list with our own data vallist.ListItems.Clear(); var items = new List <Grasshopper.Kernel.Special.GH_ValueListItem>(); items.Add(new Grasshopper.Kernel.Special.GH_ValueListItem("Default", "0")); items.Add(new Grasshopper.Kernel.Special.GH_ValueListItem("RotateZ", "1")); items.Add(new Grasshopper.Kernel.Special.GH_ValueListItem("RotateY", "2")); items.Add(new Grasshopper.Kernel.Special.GH_ValueListItem("RotateX", "3")); vallist.ListItems.AddRange(items); // Until now, the slider is a hypothetical object. // This command makes it 'real' and adds it to the canvas. GrasshopperDocument.AddObject(vallist, false); //Connect the new slider to this component Component.Params.Input[index].AddSource(vallist); Component.Params.Input[index].CollectData(); }
public static CanvasControlAttributes TaskCardAttributes(IGH_Component parent, TH_Task task) { var atts = new CanvasControlAttributes(parent); var control = new TaskCardControl(atts, task); atts.Control = control; return(atts); }
public override void AddedToDocument(GH_Document document) { base.AddedToDocument(document); Component = this; GrasshopperDocument = Instances.ActiveCanvas.Document; GHDEFNAME = RemoveSpecialCharacters(GrasshopperDocument.DisplayName.ToString()); }
/// <summary> /// This is the method that actually does the work. /// </summary> /// <param name="DA">The DA object is used to retrieve from inputs and store in outputs.</param> protected override void SolveInstance(IGH_DataAccess DA) { // 0. Setup input Component = this; GrasshopperDocument = this.OnPingDocument(); // Generate default input menu if (Component.Params.Input[0].SourceCount == 0) InputTools.GradientSelect(ref Component, ref GrasshopperDocument, 0, 11); // 1. Retrieve input int gradientType = 0; if (!DA.GetData(0, ref gradientType)) { return; } // 2. Initialize string mathString = null; // 3. Define gradients here // Assume unitized domain ( 0<x<1 , 0<y<1, 0<z<1), where radius values range from minRadius (mathString=0) to maxRadius (mathString=1) // Based on this assumption, the actual values are scaled to the size of the bounding box of the lattice switch (gradientType) { case 0: // Linear (X) mathString = "Abs(x)"; break; case 1: // Linear (Y) mathString = "Abs(y)"; break; case 2: // Linear (Z) mathString = "Abs(z)"; break; case 3: // Centered (X) mathString = "Abs(2*x-1)"; break; case 4: // Centered (Y) mathString = "Abs(2*y-1)"; break; case 5: // Centered (Z) mathString = "Abs(2*z-1)"; break; case 6: // Cylindrical (X) mathString = "Sqrt(Abs(2*y-1)^2 + Abs(2*z-1)^2)/Sqrt(2)"; break; case 7: // Cylindrical (Y) mathString = "Sqrt(Abs(2*x-1)^2 + Abs(2*z-1)^2)/Sqrt(2)"; break; case 8: // Cylindrical (Z) mathString = "Sqrt(Abs(2*x-1)^2 + Abs(2*y-1)^2)/Sqrt(2)"; break; case 9: // Spherical mathString = "Sqrt(Abs(2*x-1)^2 + Abs(2*y-1)^2 + Abs(2*z-1)^2)/Sqrt(3)"; break; // If you add a new gradient, don't forget to add it in the value list (GradientSelect method) } // Output report DA.SetData(0, mathString); }
public NormalAttributeWithControl(GH_Component owner, List <HuControl> ControlList) : base(owner) { this.Component = owner; this.ControlList = ControlList; this.ControlNumber = this.ControlList.Count; this.AttributeUtil = new AttributeUtil(owner); SetUpTimer(); }
/// <summary> /// This is the method that actually does the work. /// </summary> /// <param name="DA">The DA object is used to retrieve from inputs and store in outputs.</param> protected override void SolveInstance(IGH_DataAccess DA) { IGH_Component Component = this; GH_Document GrasshopperDocument = this.OnPingDocument(); // Create input parameters bool trigger = false; string sourceGroup = null; string targetGroup = null; int sourceIndex = 0; int targetIndex = 0; // Assign input data DA.GetData(0, ref sourceGroup); DA.GetData(1, ref targetGroup); DA.GetData(2, ref sourceIndex); DA.GetData(3, ref targetIndex); DA.GetData(4, ref trigger); // -------------------------------------------------------------------------------------------------------------------------- if (!trigger) { return; } List <IGH_Param> targetParam = new List <IGH_Param>(); List <IGH_Param> sourceParam = new List <IGH_Param>(); foreach (IGH_DocumentObject docObject in GrasshopperDocument.Objects) //for every GH component in document { // if the pathname of the actual object is the same as the Pathname of the targetgroup // put the docObject in the group "gp" as a GH special group // then take out the Params of the target objects if (docObject.Attributes.PathName == "Group (" + targetGroup + ")") { Grasshopper.Kernel.Special.GH_Group gp = docObject as Grasshopper.Kernel.Special.GH_Group; targetParam = getParams(gp.Objects(), targetIndex, sourceIndex, true); } // the same as above but for the source objects else if (docObject.Attributes.PathName == "Group (" + sourceGroup + ")") { Grasshopper.Kernel.Special.GH_Group gp = docObject as Grasshopper.Kernel.Special.GH_Group; sourceParam = getParams(gp.Objects(), sourceIndex, sourceIndex, false); } } int nbI = targetParam.Count(); int nbO = sourceParam.Count(); int nb = Math.Max(nbI, nbO); for (int i = 0; i < nb; i++) { targetParam[i % nbI].AddSource(sourceParam[i % nbO]); } }
public static Bitmap GetObjectBitmap(IGH_DocumentObject obj, bool isInput, out IGH_Param dataParam, byte?index = null, int marginThickness = 10, int maxDistanceToWorkArea = 150) { dataParam = null; GH_Canvas canvas = new GH_Canvas(); canvas.Document = new GH_Document(); AddAObjectToCanvas(obj, new PointF(), false, canvas); obj.Attributes.Bounds = new System.Drawing.RectangleF(-obj.Attributes.Bounds.Width / 2, -obj.Attributes.Bounds.Height / 2, obj.Attributes.Bounds.Width, obj.Attributes.Bounds.Height); if (index.HasValue && obj is IGH_Component) { IGH_Component component = obj as IGH_Component; IGH_Param param = null; RectangleF renderRect = RectangleF.Empty; switch (isInput) { case true: if (component.Params.Output.Count <= index.Value) { return(null); } param = component.Params.Output[index.Value]; renderRect = param.Attributes.Bounds; float move = obj.Attributes.Bounds.Right - renderRect.Right - 2; renderRect = new RectangleF(new PointF(renderRect.X + move, renderRect.Y), renderRect.Size); break; case false: if (component.Params.Input.Count <= index.Value) { return(null); } param = component.Params.Input[index.Value]; renderRect = param.Attributes.Bounds; float move1 = obj.Attributes.Bounds.Left - renderRect.Left + 2; renderRect = new RectangleF(new PointF(renderRect.X + move1, renderRect.Y), renderRect.Size); break; } if (param != null && renderRect != RectangleF.Empty) { dataParam = param; canvas.CanvasPostPaintObjects += (cvs) => { canvas.Graphics.DrawPath(new Pen(new SolidBrush(ColorExtension.OnColor), 2), TextBox.GetRoundRectangle(renderRect, 3)); }; } } else if (index.HasValue && obj is IGH_Param) { dataParam = obj as IGH_Param; } return(GetObjectBitmap(obj, canvas, marginThickness, maxDistanceToWorkArea)); }
protected override void SolveInstance(IGH_DataAccess DA) { Component = this; GrasshopperDocument = OnPingDocument(); string size = ""; string usage = ""; string energy = ""; string structural = ""; bool input = false; if (!DA.GetData(0, ref input)) { return; } if (input && Params.Input[1].SourceCount == 0 && Params.Input[2].SourceCount == 0 && Params.Input[3].SourceCount == 0 && Params.Input[4].SourceCount == 0) { CreateAccentList(SIZE_VALUES, "Building size", 1, 200, -20); CreateAccentList(USAGE_VALUES, "Building usage", 2, 275, -10); CreateAccentList(ENERGY_VALUES, "Energy preference", 3, 230, 0); CreateAccentList(STRUCTUAL_VALUES, "Structual material", 4, 202, 10); Message = "Component activated."; } if (!DA.GetData(1, ref size)) { return; } if (!DA.GetData(2, ref usage)) { return; } if (!DA.GetData(3, ref energy)) { return; } if (!DA.GetData(4, ref structural)) { return; } var outputList = new List <string>(); outputList.Add(size); outputList.Add(usage); outputList.Add(energy); outputList.Add(structural); DA.SetDataList(0, outputList); }
public SetComponentWindow(IGH_Component C, wObject W, string T, int R) { switch (T) { case "TextBox": TextBox A15 = (TextBox)C; A15.Elements[R] = W; break; } }
public static void SwapGroups(GH_Document document, IGH_Component component, IGH_Component upgradedComponent) { var groups = document .Objects .OfType <GH_Group>() .Where(gr => gr.ObjectIDs.Contains(component.InstanceGuid)) .ToList(); groups.ForEach(g => g.AddObject(upgradedComponent.InstanceGuid)); }
/// <summary> /// Upgrade an existing object. /// </summary> /// <param name="target">Object to upgrade.</param> /// <param name="document">Document that contains the object.</param> /// <returns> /// The newly created object on success, null on failure. /// </returns> public IGH_DocumentObject Upgrade(IGH_DocumentObject target, GH_Document document) { IGH_Component component = target as IGH_Component; if (component == null) { return(null); } return(GH_UpgradeUtil.SwapComponents(component, this.UpgradeTo)); }
public AttribCompo(IGH_Component PythonInterfaceComponent) : base(PythonInterfaceComponent) { string Name = System.Environment.UserName; ChangedText = Resources.SavedPythonFile.Shellinit.Replace("##CreatedBy##", Name); ChangedText = ChangedText.Replace("##at##", at); thisIndex2 = Globals.index; }
public StormCloudWindow(DesignToolVM designtoolvm, IGH_Component comp) { InitializeComponent(); this.Component = (InterOptComponent)comp; this.myDesignToolVM = designtoolvm; this.myDesignToolVM.Pos = new System.Windows.Media.Media3D.Point3D(0, 0, 20); this.myDesignToolVM.LookDir = new System.Windows.Media.Media3D.Vector3D(0, 0, -1); this.Pop.Minimum = NCOL; this.DataContext = designtoolvm; }
public ClusterComponentAttributes(IGH_Component component) : base(component) { MyComponent = (ClusterComponent)component; this.DesignMapSorted = new List <List <List <double> > >(); this.ClusterAves = new List <List <double> >(); this.DesignMap = new List <List <double> >(); this.ClusterMaxs = new List <List <double> >(); this.ClusterMins = new List <List <double> >(); }
public IGH_DocumentObject Upgrade(IGH_DocumentObject target, GH_Document document) { IGH_Component component = target as IGH_Component; if (component == null) { return(null); } IGH_Component swappedComp = GH_UpgradeUtil.SwapComponents(component, UpgradeTo); return(swappedComp); }
public EffectsComponentAttributes(IGH_Component component) : base(component) { MyComponent = (EffectsComponent)component; this.EffectIndicesList = new List <List <int> >(); this.DesignMapEffects = new List <List <double> >(); this.OverallAvg = new List <double>(); this.IndEffectsSum = new List <List <List <List <double> > > >(); this.IndEffectsAvg = new List <List <List <double> > >(); this.OverallEff = new List <List <double> >(); }
public RectangleF LayoutComponentBox2(IGH_Component owner) { GH_SwitcherComponent gH_SwitcherComponent = (GH_SwitcherComponent)owner; int val = Math.Max(gH_SwitcherComponent.StaticData.GetComponentInputSection().Count, gH_SwitcherComponent.StaticData.GetComponentOutputSection().Count) * 20; val = Math.Max(val, 24); int num = 24; if (!GH_Attributes <IGH_Component> .IsIconMode(owner.IconDisplayMode)) { val = Math.Max(val, GH_Convert.ToSize((SizeF)GH_FontServer.MeasureString(owner.NickName, StandardFont.largeFont())).Width + 6); } return(GH_Convert.ToRectangle(new RectangleF(owner.Attributes.Pivot.X - 0.5f * (float)num, owner.Attributes.Pivot.Y - 0.5f * (float)val, num, val))); }
public IGH_DocumentObject Upgrade(IGH_DocumentObject target, GH_Document document) { IGH_Component component = target as IGH_Component; if (component == null) { return(null); } GH_Component swappedComp = GH_UpgradeUtil.SwapComponents(component, this.UpgradeTo) as GH_Component; swappedComp.Params.Output[0].DataMapping = GH_DataMapping.Flatten; return(swappedComp); }
public IGH_DocumentObject Upgrade(IGH_DocumentObject target, GH_Document document) { IGH_Component component = target as IGH_Component; if (component == null) { return(null); } IGH_Component upgradedComponent = GH_UpgradeUtil.SwapComponents(component, UpgradeTo); UpgradeUtils.SwapGroups(document, component, upgradedComponent); return(upgradedComponent); }
public RectangleF LayoutBounds2(IGH_Component owner, RectangleF bounds) { GH_SwitcherComponent gH_SwitcherComponent = (GH_SwitcherComponent)owner; foreach (IGH_Param item in gH_SwitcherComponent.StaticData.GetComponentInputSection()) { bounds = RectangleF.Union(bounds, item.Attributes.Bounds); } foreach (IGH_Param item2 in gH_SwitcherComponent.StaticData.GetComponentOutputSection()) { bounds = RectangleF.Union(bounds, item2.Attributes.Bounds); } bounds.Inflate(2f, 2f); return(bounds); }
public StepperComponentAttributes(IGH_Component component) : base(component) { MyComponent = (StepperComponent)component; this.Gradient = new List <List <double> >(); this.DifOne = new List <List <double> >(); this.DifTwo = new List <List <double> >(); this.DesignMapStepperOne = new List <List <double> >(); this.DesignMapStepperTwo = new List <List <double> >(); this.DesignMapStepperCombined = new List <List <double> >(); this.ObjValsOne = new List <List <double> >(); this.ObjValsTwo = new List <List <double> >(); this.IsoPerf = new List <double>(); }
public ModelBuilder() : base("ModelBuilder", "BN Model", "Description", "Lab Mouse", "Model") { this.model = null; this.priors = null; this.BinRanges = null; this.PSliders = null; this.POutputs = null; this.targets = null; this.directory = new List <string>(); this.datagencomponent = null; this.doc = null; this.csvfilepath = null; }
public IGH_DocumentObject Upgrade(IGH_DocumentObject target, GH_Document document) { ValueListener_Component_DEPRECATED component = target as ValueListener_Component_DEPRECATED; if (component == null) { return(null); } IGH_Component swappedComp = GH_UpgradeUtil.SwapComponents(component, this.UpgradeTo); ValueListener_Component swappedValListener = swappedComp as ValueListener_Component; swappedValListener.AddEventsEnabled = component.AddEventsEnabled; swappedValListener.updateMessage(); return(swappedComp); }
public IGH_DocumentObject Upgrade(IGH_DocumentObject target, GH_Document document) { IGH_Component component = target as IGH_Component; if (component == null) { return(null); } IGH_Component upgradedComponent = GH_UpgradeUtil.SwapComponents(component, UpgradeTo); upgradedComponent.Params.Input[0].Access = GH_ParamAccess.item; upgradedComponent.Params.Input[2].Access = GH_ParamAccess.tree; UpgradeUtils.SwapGroups(document, component, upgradedComponent); return(upgradedComponent); }
// Grasshopper.Kernel.Attributes.GH_ComponentAttributes public void LayoutInputParamsJR(IGH_Component owner, RectangleF componentBox) { int count = owner.Params.Input.Count; if (count == 0) { return; } int width = 0; try { System.Collections.Generic.List<IGH_Param>.Enumerator enumerator = owner.Params.Input.GetEnumerator(); while (enumerator.MoveNext()) { IGH_Param param = enumerator.Current; width = Math.Max(width, GH_FontServer.StringWidth(param.Name, paramfont)); } } finally { } width = Math.Max(width + 6, 12); float pixelsPerParam = componentBox.Height / count; int arg_82_0 = 0; int num = count - 1; for (int i = arg_82_0; i <= num; i++) { IGH_Param param2 = owner.Params.Input[i]; if (param2.Attributes == null) { param2.Attributes = new GH_LinkedParamAttributes(param2, owner.Attributes); } float X = componentBox.X - width; float Y = componentBox.Y + i * pixelsPerParam; float W = width - 3; float H = pixelsPerParam; IGH_Attributes arg_103_0 = param2.Attributes; PointF pivot = new PointF(X + 0.5f * width, Y + 0.5f * pixelsPerParam); arg_103_0.Pivot = pivot; IGH_Attributes arg_12A_0 = param2.Attributes; RectangleF @in = new RectangleF(X, Y, W, H); arg_12A_0.Bounds = GH_Convert.ToRectangle(@in); } }
/// <summary> /// This is the method that actually does the work. /// </summary> /// <param name="DA">The DA object is used to retrieve from inputs and store in outputs.</param> protected override void SolveInstance(IGH_DataAccess DA) { // 0. Generate input menu list Component = this; GrasshopperDocument = this.OnPingDocument(); // Only generate it if the input has no source if (Component.Params.Input[0].SourceCount == 0) { InputTools.TopoSelect(ref Component, ref GrasshopperDocument, 0, 11); } // 1. Retrieve input int cellType = 0; if (!DA.GetData(0, ref cellType)) { return; } // 2. Instantiate line list var lines = new List<Line>(); // 3. Set cell size double d = 5; // 4. Switch statement for the different cell types switch (cellType) { // "GRID" case 0: lines = GridLines(d); break; // "X" case 1: lines = XLines(d); break; // "STAR" case 2: lines = StarLines(d); break; // "CROSS" case 3: lines = CrossLines(d); break; // "TESSERACT" case 4: lines = TesseractLines(d); break; // "VINTILES" case 5: lines = VintileLines(d); break; // "OCTET" case 6: lines = OctetLines(d); break; // "DIAMOND" case 7: lines = DiamondLines(d); break; // "HONEYCOMB" case 8: lines = Honeycomb(d); break; // "AUXETIC HONEYCOMB" case 9: lines = AuxeticHoneycomb(d); break; } // 5. Instantiate UnitCell object and check validity. var cell = new UnitCell(lines); if (!cell.isValid) { AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "Invalid cell - this is embarassing."); } // 6. Construct normalized cell lines (for optional output) var lines2 = new List<Line>(); foreach (IndexPair nodePair in cell.NodePairs) { lines2.Add(new Line(cell.Nodes[nodePair.I], cell.Nodes[nodePair.J])); } // 7. Set output (as LatticeCellGoo) DA.SetData(0, new UnitCellGoo(cell)); DA.SetDataList(1, lines2); }
public HSAttributes(IGH_Component nComponent) : base(nComponent) { m_owner = (HSComponent)nComponent; }
public CustomAttributes2(IGH_Component owner) : base(owner) { }
public SettingsComponentAttributes(IGH_Component SettingsComponent) : base(SettingsComponent) { }
public TortugaComponentAttributes(IGH_Component MaterialEditor) : base(MaterialEditor) { }
private List<string> __out = new List<string>(); //Do not modify this list directly. #endregion Fields #region Methods public override void InvokeRunScript(IGH_Component owner, object rhinoDocument, int iteration, List<object> inputs, IGH_DataAccess DA) { //Prepare for a new run... //1. Reset lists this.__out.Clear(); this.__err.Clear(); this.Component = owner; this.Iteration = iteration; this.GrasshopperDocument = owner.OnPingDocument(); this.RhinoDocument = rhinoDocument as Rhino.RhinoDoc; this.owner = this.Component; this.runCount = this.Iteration; this. doc = this.RhinoDocument; //2. Assign input parameters Mesh Profile = default(Mesh); if (inputs[0] != null) { Profile = (Mesh)(inputs[0]); } List<Mesh> x = null; if (inputs[1] != null) { x = GH_DirtyCaster.CastToList<Mesh>(inputs[1]); } bool y = default(bool); if (inputs[2] != null) { y = (bool)(inputs[2]); } //3. Declare output parameters object A = null; //4. Invoke RunScript RunScript(Profile, x, y, ref A); try { //5. Assign output parameters to component... if (A != null) { if (GH_Format.TreatAsCollection(A)) { IEnumerable __enum_A = (IEnumerable)(A); DA.SetDataList(1, __enum_A); } else { if (A is Grasshopper.Kernel.Data.IGH_DataTree) { //merge tree DA.SetDataTree(1, (Grasshopper.Kernel.Data.IGH_DataTree)(A)); } else { //assign direct DA.SetData(1, A); } } } else { DA.SetData(1, null); } } catch (Exception ex) { this.__err.Add(string.Format("Script exception: {0}", ex.Message)); } finally { //Add errors and messages... if (owner.Params.Output.Count > 0) { if (owner.Params.Output[0] is Grasshopper.Kernel.Parameters.Param_String) { List<string> __errors_plus_messages = new List<string>(); if (this.__err != null) { __errors_plus_messages.AddRange(this.__err); } if (this.__out != null) { __errors_plus_messages.AddRange(this.__out); } if (__errors_plus_messages.Count > 0) DA.SetDataList(0, __errors_plus_messages); } } } }
public BimVisualizerAttributes(IGH_Component component) : base(component) { _component = (BimVisualiser) component; _boundingBoxes = new List<RectangleF>(); }