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); }
protected void FixLayout(List <ExtendedPlug> outs) { GH_SwitcherComponent gH_SwitcherComponent = (GH_SwitcherComponent)base.Owner; float width = this.Bounds.Width; if (_minWidth > width) { this.Bounds = (new RectangleF(this.Bounds.X, this.Bounds.Y, _minWidth, this.Bounds.Height)); } float num = this.Bounds.Width - width; foreach (IGH_Param componentOutput in gH_SwitcherComponent.StaticData.GetComponentOutputs()) { PointF pivot = componentOutput.Attributes.Pivot; RectangleF bounds = componentOutput.Attributes.Bounds; componentOutput.Attributes.Pivot = (new PointF(pivot.X + num, pivot.Y)); componentOutput.Attributes.Bounds = (new RectangleF(bounds.Location.X + num, bounds.Location.Y, bounds.Width, bounds.Height)); } foreach (IGH_Param componentInput in gH_SwitcherComponent.StaticData.GetComponentInputs()) { PointF pivot2 = componentInput.Attributes.Pivot; RectangleF bounds2 = componentInput.Attributes.Bounds; componentInput.Attributes.Pivot = (new PointF(pivot2.X + num, pivot2.Y)); componentInput.Attributes.Bounds = (new RectangleF(bounds2.Location.X + num, bounds2.Location.Y, bounds2.Width, bounds2.Height)); } }
public void InitializeUnitParameters() { GH_SwitcherComponent gH_SwitcherComponent = (GH_SwitcherComponent)base.Owner; if (gH_SwitcherComponent.EvalUnits != null) { foreach (EvaluationUnit evalUnit in gH_SwitcherComponent.EvalUnits) { foreach (ExtendedPlug input in evalUnit.Inputs) { if (input.Parameter.Attributes == null) { input.Parameter.Attributes = (new GH_LinkedParamAttributes(input.Parameter, this)); } } foreach (ExtendedPlug output in evalUnit.Outputs) { if (output.Parameter.Attributes == null) { output.Parameter.Attributes = (new GH_LinkedParamAttributes(output.Parameter, this)); } } } } }
public GH_SwitcherComponentAttributes(GH_SwitcherComponent component) : base(component) { collection = new GH_MenuCollection(); composedCollection = new GH_MenuCollection(); composedCollection.Merge(collection); CreateUnitDropDown(); InitializeUnitParameters(); }
public GH_SwitchAction(GH_SwitcherComponent component, string newUnit) : base() { if (component == null) { throw new ArgumentNullException("component"); } oldState = GH_SwitcherConnectivity.Create(component); this.newUnit = newUnit; }
protected override void Internal_Undo(GH_Document doc) { IGH_DocumentObject val = doc.FindObject(oldState.ComponentId, true); if (val == null || !(val is GH_SwitcherComponent)) { throw new GH_UndoException("Switcher component with id[" + oldState.ComponentId + "] not found"); } GH_SwitcherComponent component = (GH_SwitcherComponent)val; oldState.Apply(component, doc); }
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))); }
protected override void Layout() { this.Pivot = ((PointF)GH_Convert.ToPoint(this.Pivot)); LayoutBaseComponent(); GH_SwitcherComponent gH_SwitcherComponent = (GH_SwitcherComponent)base.Owner; List <ExtendedPlug> inputs = new List <ExtendedPlug>(); List <ExtendedPlug> outputs = new List <ExtendedPlug>(); composedCollection.GetMenuPlugs(ref inputs, ref outputs, onlyVisible: true); LayoutMenuInputs(base.m_innerBounds); LayoutMenuOutputs(base.m_innerBounds); this.Bounds = (LayoutExtBounds(base.m_innerBounds, inputs, outputs)); FixLayout(outputs); LayoutMenu(); }
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 void Apply(GH_SwitcherComponent component, GH_Document document) { if (noUnit) { component.ClearUnit(recompute: true, recordEvent: false); } else { component.SwitchUnit(unit, recompute: true, recordEvent: false); } for (int i = 0; i < inputs.Count; i++) { GH_SwitcherParamState gH_SwitcherParamState = inputs[i]; int num = component.Params.IndexOfInputParam(gH_SwitcherParamState.ParameterId); if (num == -1) { continue; } IGH_Param val = component.Params.Input[num]; for (int j = 0; j < gH_SwitcherParamState.Targets.Count; j++) { IGH_Param val2 = document.FindParameter(gH_SwitcherParamState.Targets[j]); if (val2 != null) { val.AddSource(val2); } } } for (int k = 0; k < outputs.Count; k++) { GH_SwitcherParamState gH_SwitcherParamState2 = outputs[k]; int num2 = component.Params.IndexOfOutputParam(gH_SwitcherParamState2.ParameterId); if (num2 == -1) { continue; } IGH_Param val3 = component.Params.Output[num2]; for (int l = 0; l < gH_SwitcherParamState2.Targets.Count; l++) { IGH_Param val4 = document.FindParameter(gH_SwitcherParamState2.Targets[l]); if (val4 != null) { val4.AddSource(val3); } } } }
protected void LayoutBaseComponent() { GH_SwitcherComponent gH_SwitcherComponent = (GH_SwitcherComponent)base.Owner; this.Pivot = ((PointF)GH_Convert.ToPoint(this.Pivot)); base.m_innerBounds = LayoutComponentBox2(base.Owner); int num = ComputeW_ico(base.Owner); float width = composedCollection.GetMinLayoutSize().Width; float num2 = Math.Max(MinWidth, width); int add_offset = 0; if (num2 > (float)num) { add_offset = (int)((double)(num2 - (float)num) / 2.0); } LayoutInputParams2(base.Owner, base.m_innerBounds, add_offset); LayoutOutputParams2(base.Owner, base.m_innerBounds, add_offset); this.Bounds = (LayoutBounds2(base.Owner, base.m_innerBounds)); }
protected override void Internal_Redo(GH_Document doc) { IGH_DocumentObject val = doc.FindObject(oldState.ComponentId, true); if (val == null || !(val is GH_SwitcherComponent)) { throw new GH_UndoException("Switcher component with id[" + oldState.ComponentId + "] not found"); } GH_SwitcherComponent gH_SwitcherComponent = (GH_SwitcherComponent)val; if (newUnit != null) { gH_SwitcherComponent.SwitchUnit(newUnit, recompute: true, recordEvent: false); } else { gH_SwitcherComponent.ClearUnit(recompute: false); } }
public static void RenderComponentParameters2(GH_Canvas canvas, Graphics graphics, IGH_Component owner, GH_PaletteStyle style) { GH_SwitcherComponent gH_SwitcherComponent = (GH_SwitcherComponent)owner; int zoomFadeLow = GH_Canvas.ZoomFadeLow; if (zoomFadeLow >= 5) { StringFormat farCenter = GH_TextRenderingConstants.FarCenter; canvas.SetSmartTextRenderingHint(); SolidBrush solidBrush = new SolidBrush(Color.FromArgb(zoomFadeLow, style.Text)); foreach (IGH_Param staticInput in gH_SwitcherComponent.StaticData.StaticInputs) { RectangleF bounds = staticInput.Attributes.Bounds; if (bounds.Width >= 1f) { graphics.DrawString(staticInput.NickName, StandardFont.font(), solidBrush, bounds, farCenter); GH_LinkedParamAttributes obj = (GH_LinkedParamAttributes)staticInput.Attributes; GH_StateTagList val = (GH_StateTagList)typeof(GH_LinkedParamAttributes).GetField("m_renderTags", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(obj); if (val != null) { val.RenderStateTags(graphics); } } } farCenter = GH_TextRenderingConstants.NearCenter; foreach (IGH_Param staticOutput in gH_SwitcherComponent.StaticData.StaticOutputs) { RectangleF bounds2 = staticOutput.Attributes.Bounds; if (bounds2.Width >= 1f) { graphics.DrawString(staticOutput.NickName, StandardFont.font(), solidBrush, bounds2, farCenter); GH_LinkedParamAttributes obj2 = (GH_LinkedParamAttributes)staticOutput.Attributes; GH_StateTagList val2 = (GH_StateTagList)typeof(GH_LinkedParamAttributes).GetField("m_renderTags", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(obj2); if (val2 != null) { val2.RenderStateTags(graphics); } } } solidBrush.Dispose(); } }
public RuntimeComponentData(GH_SwitcherComponent component) { this.component = component; cachedName = component.Name; cachedNickname = component.NickName; cachedDescription = component.Description; cachedIcon = component.Icon_24x24; dynInputs = new List <IGH_Param>(); dynOutputs = new List <IGH_Param>(); stcInputs = new List <IGH_Param>(); stcOutputs = new List <IGH_Param>(); foreach (IGH_Param item in component.Params.Input) { stcInputs.Add(item); } foreach (IGH_Param item2 in component.Params.Output) { stcOutputs.Add(item2); } }
private void ComposeMenu() { GH_SwitcherComponent gH_SwitcherComponent = (GH_SwitcherComponent)base.Owner; composedCollection = new GH_MenuCollection(); EvaluationUnit activeUnit = gH_SwitcherComponent.ActiveUnit; if (activeUnit != null && activeUnit.Context.Collection != null) { composedCollection.Merge(gH_SwitcherComponent.ActiveUnit.Context.Collection); } if (collection != null) { composedCollection.Merge(collection); } if (unitMenuCollection != null) { composedCollection.Merge(unitMenuCollection); } }
protected void CreateUnitDropDown() { GH_SwitcherComponent gH_SwitcherComponent = (GH_SwitcherComponent)base.Owner; if (gH_SwitcherComponent.EvalUnits != null && gH_SwitcherComponent.EvalUnits.Count != 0 && (gH_SwitcherComponent.EvalUnits.Count != 1 || gH_SwitcherComponent.UnitlessExistence)) { MenuPanel menuPanel = new MenuPanel(0, "panel_units"); menuPanel.Header = "Unit selection"; string text = gH_SwitcherComponent.UnitMenuName; if (text == null) { text = "Evaluation Units"; } string text2 = gH_SwitcherComponent.UnitMenuHeader; if (text2 == null) { text2 = "Select evaluation unit"; } unitMenuCollection = new GH_MenuCollection(); GH_ExtendableMenu gH_ExtendableMenu = new GH_ExtendableMenu(0, "menu_units"); gH_ExtendableMenu.Name = text; gH_ExtendableMenu.Header = text2; gH_ExtendableMenu.AddControl(menuPanel); _UnitDrop = new MenuDropDown(0, "dropdown_units", "units"); _UnitDrop.VisibleItemCount = 10; _UnitDrop.ValueChanged += _UnitDrop__valueChanged; _UnitDrop.Header = "Evaluation unit selector"; menuPanel.AddControl(_UnitDrop); List <EvaluationUnit> evalUnits = gH_SwitcherComponent.EvalUnits; if (gH_SwitcherComponent.UnitlessExistence) { _UnitDrop.AddItem("--NONE--", null); } for (int i = 0; i < evalUnits.Count; i++) { _UnitDrop.AddItem(evalUnits[i].Name, evalUnits[i].DisplayName, evalUnits[i]); } gH_ExtendableMenu.Expand(); unitMenuCollection.AddMenu(gH_ExtendableMenu); } }
public RectangleF LayoutExtBounds(RectangleF bounds, List <ExtendedPlug> ins, List <ExtendedPlug> outs) { GH_SwitcherComponent gH_SwitcherComponent = (GH_SwitcherComponent)base.Owner; foreach (IGH_Param componentInput in gH_SwitcherComponent.StaticData.GetComponentInputs()) { RectangleF bounds2 = componentInput.Attributes.Bounds; if (bounds2.X < bounds.X) { float num = bounds.X - bounds2.X; bounds.X = bounds2.X; bounds.Width += num; } if (bounds2.X + bounds2.Width > bounds.X + bounds.Width) { float num2 = bounds2.X + bounds2.Width - (bounds.X + bounds.Width); bounds.Width += num2; } } foreach (IGH_Param componentOutput in gH_SwitcherComponent.StaticData.GetComponentOutputs()) { RectangleF bounds3 = componentOutput.Attributes.Bounds; if (bounds3.X < bounds.X) { float num3 = bounds.X - bounds3.X; bounds.X = bounds3.X; bounds.Width += num3; } if (bounds3.X + bounds3.Width > bounds.X + bounds.Width) { float num4 = bounds3.X + bounds3.Width - (bounds.X + bounds.Width); bounds.Width += num4; } } bounds.Inflate(2f, 2f); return(bounds); }
public static GH_SwitcherConnectivity Create(GH_SwitcherComponent component) { GH_SwitcherConnectivity gH_SwitcherConnectivity = new GH_SwitcherConnectivity(); gH_SwitcherConnectivity.componentId = component.InstanceGuid; EvaluationUnit activeUnit = component.ActiveUnit; if (activeUnit != null) { gH_SwitcherConnectivity.noUnit = false; gH_SwitcherConnectivity.unit = activeUnit.Name; } else if (component.UnitlessExistence) { gH_SwitcherConnectivity.noUnit = true; } foreach (IGH_Param item in component.Params.Input) { GH_SwitcherParamState gH_SwitcherParamState = new GH_SwitcherParamState(0, item.InstanceGuid); gH_SwitcherConnectivity.inputs.Add(gH_SwitcherParamState); foreach (IGH_Param source in item.Sources) { gH_SwitcherParamState.Targets.Add(source.InstanceGuid); } } foreach (IGH_Param item2 in component.Params.Output) { GH_SwitcherParamState gH_SwitcherParamState2 = new GH_SwitcherParamState(GH_ParameterSide.Output, item2.InstanceGuid); gH_SwitcherConnectivity.outputs.Add(gH_SwitcherParamState2); foreach (IGH_Param recipient in item2.Recipients) { gH_SwitcherParamState2.Targets.Add(recipient.InstanceGuid); } } return(gH_SwitcherConnectivity); }
public void LayoutOutputParams2(IGH_Component owner, RectangleF componentBox, int add_offset) { GH_SwitcherComponent gH_SwitcherComponent = (GH_SwitcherComponent)owner; List <IGH_Param> componentOutputSection = gH_SwitcherComponent.StaticData.GetComponentOutputSection(); int count = componentOutputSection.Count; if (count == 0) { return; } int num = 0; int num2 = 0; foreach (IGH_Param componentOutput in gH_SwitcherComponent.StaticData.GetComponentOutputs()) { int val = ((List <IGH_StateTag>)componentOutput.StateTags).Count * 20; num2 = Math.Max(num2, val); num = Math.Max(num, GH_FontServer.StringWidth(componentOutput.NickName, StandardFont.font())); } num = Math.Max(num + 6, 12); num += num2 + add_offset; float num3 = componentBox.Height / (float)count; for (int i = 0; i < count; i++) { IGH_Param val2 = componentOutputSection[i]; if (val2.Attributes == null) { val2.Attributes = (new GH_LinkedParamAttributes(val2, owner.Attributes)); } float num4 = componentBox.Right + 3f; float num5 = componentBox.Y + (float)i * num3; float width = num; float height = num3; PointF pivot = new PointF(num4 + 0.5f * (float)num, num5 + 0.5f * num3); val2.Attributes.Pivot = (pivot); RectangleF rectangleF = new RectangleF(num4, num5, width, height); val2.Attributes.Bounds = ((RectangleF)GH_Convert.ToRectangle(rectangleF)); } bool flag = false; for (int j = 0; j < count; j++) { IGH_Param val3 = componentOutputSection[j]; GH_LinkedParamAttributes val4 = (GH_LinkedParamAttributes)val3.Attributes; FieldInfo field = typeof(GH_LinkedParamAttributes).GetField("m_renderTags", BindingFlags.Instance | BindingFlags.NonPublic); GH_StateTagList val5 = val3.StateTags; if (!(field != null)) { continue; } if (((List <IGH_StateTag>)val5).Count == 0) { val5 = null; field.SetValue(val4, val5); } if (val5 != null) { flag = true; Rectangle rectangle = GH_Convert.ToRectangle(val4.Bounds); rectangle.Width -= num2; val5.Layout(rectangle, GH_StateTagLayoutDirection.Right); rectangle = val5.BoundingBox; if (!rectangle.IsEmpty) { val4.Bounds = (RectangleF.Union(val4.Bounds, rectangle)); } field.SetValue(val4, val5); } } if (flag) { float num6 = float.MinValue; for (int k = 0; k < count; k++) { IGH_Attributes attributes = componentOutputSection[k].Attributes; num6 = Math.Max(num6, attributes.Bounds.Right); } for (int l = 0; l < count; l++) { IGH_Attributes attributes2 = componentOutputSection[l].Attributes; RectangleF bounds = attributes2.Bounds; bounds.Width = num6 - bounds.X; attributes2.Bounds = (bounds); } } }
protected void RenderComponentCapsule2(GH_Canvas canvas, Graphics graphics, bool drawComponentBaseBox, bool drawComponentNameBox, bool drawJaggedEdges, bool drawParameterGrips, bool drawParameterNames, bool drawZuiElements) { GH_SwitcherComponent gH_SwitcherComponent = (GH_SwitcherComponent)base.Owner; RectangleF bounds = this.Bounds; this.Bounds = (bounds); if (!canvas.Viewport.IsVisible(ref bounds, 10f)) { return; } GH_Palette val = GH_CapsuleRenderEngine.GetImpliedPalette(base.Owner); if ((int)val == 0 && !base.Owner.IsPreviewCapable) { val = GH_Palette.Hidden; } GH_Capsule val2 = GH_Capsule.CreateCapsule(this.Bounds, val); bool flag = base.Owner.Params.Input .Count == 0; bool flag2 = base.Owner.Params.Output .Count == 0; val2.SetJaggedEdges(flag, flag2); GH_PaletteStyle impliedStyle = GH_CapsuleRenderEngine.GetImpliedStyle(val, this.Selected, base.Owner.Locked, base.Owner.Hidden); if (drawParameterGrips) { foreach (IGH_Param staticInput in gH_SwitcherComponent.StaticData.StaticInputs) { val2.AddInputGrip(staticInput.Attributes.InputGrip.Y); } foreach (IGH_Param dynamicInput in gH_SwitcherComponent.StaticData.DynamicInputs) { val2.AddInputGrip(dynamicInput.Attributes.InputGrip.Y); } foreach (IGH_Param staticOutput in gH_SwitcherComponent.StaticData.StaticOutputs) { val2.AddOutputGrip(staticOutput.Attributes.OutputGrip.Y); } foreach (IGH_Param dynamicOutput in gH_SwitcherComponent.StaticData.DynamicOutputs) { val2.AddOutputGrip(dynamicOutput.Attributes.OutputGrip.Y); } } graphics.SmoothingMode = SmoothingMode.HighQuality; canvas.SetSmartTextRenderingHint(); if (GH_Attributes <IGH_Component> .IsIconMode(base.Owner.IconDisplayMode)) { if (drawComponentBaseBox) { if (base.Owner.Message != null) { val2.RenderEngine.RenderMessage(graphics, base.Owner.Message, impliedStyle); } val2.Render(graphics, impliedStyle); } if (drawComponentNameBox && base.Owner.Icon_24x24 != null) { if (base.Owner.Locked) { val2.RenderEngine.RenderIcon(graphics, (Image)base.Owner.Icon_24x24_Locked, base.m_innerBounds, 0, 0); } else { val2.RenderEngine.RenderIcon(graphics, (Image)base.Owner.Icon_24x24, base.m_innerBounds, 0, 0); } } } else { if (drawComponentBaseBox) { if (base.Owner.Message != null) { val2.RenderEngine.RenderMessage(graphics, base.Owner.Message, impliedStyle); } val2.Render(graphics, impliedStyle); } if (drawComponentNameBox) { GH_Capsule obj = GH_Capsule.CreateTextCapsule(base.m_innerBounds, base.m_innerBounds, GH_Palette.Black, base.Owner.NickName, StandardFont.largeFont(), GH_Orientation.vertical_center, 3, 6); obj.Render(graphics, this.Selected, base.Owner.Locked, false); obj.Dispose(); } } if (drawComponentNameBox && base.Owner.Obsolete && Grasshopper.CentralSettings.CanvasObsoleteTags && (int)canvas.DrawingMode == 0) { GH_GraphicsUtil.RenderObjectOverlay(graphics, Owner, base.m_innerBounds); } if (drawParameterNames) { RenderComponentParameters2(canvas, graphics, base.Owner, impliedStyle); } if (drawZuiElements) { this.RenderVariableParameterUI(canvas, graphics); } val2.Dispose(); }
public void LayoutMenuOutputs(RectangleF componentBox) { GH_SwitcherComponent obj = (GH_SwitcherComponent)base.Owner; float num = 0f; int num2 = 0; foreach (IGH_Param componentOutput in obj.StaticData.GetComponentOutputs()) { int val = 20 * ((List <IGH_StateTag>)componentOutput.StateTags).Count; num2 = Math.Max(num2, val); num = Math.Max(num, GH_FontServer.StringWidth(componentOutput.NickName, StandardFont.font())); } num = Math.Max(num + 6f, 12f); num += (float)num2; float num3 = this.Bounds.Height; for (int i = 0; i < composedCollection.Menus.Count; i++) { float num4 = -1f; float num5 = 0f; bool expanded = composedCollection.Menus[i].Expanded; if (expanded) { num4 = num3 + composedCollection.Menus[i].Height; num5 = Math.Max(composedCollection.Menus[i].Inputs.Count, composedCollection.Menus[i].Outputs.Count) * 20; } else { num4 = num3 + 5f; num5 = 0f; } List <ExtendedPlug> outputs = composedCollection.Menus[i].Outputs; int count = outputs.Count; if (count != 0) { float num6 = num5 / (float)count; for (int j = 0; j < count; j++) { IGH_Param parameter = outputs[j].Parameter; if (parameter.Attributes == null) { parameter.Attributes = (new GH_LinkedParamAttributes(parameter, this)); } float num7 = componentBox.Right + 3f; float num8 = num4 + componentBox.Y + (float)j * num6; float width = num; float height = num6; PointF pivot = new PointF(num7 + 0.5f * num, num8 + 0.5f * num6); parameter.Attributes.Pivot = (pivot); RectangleF rectangleF = new RectangleF(num7, num8, width, height); parameter.Attributes.Bounds = ((RectangleF)GH_Convert.ToRectangle(rectangleF)); } for (int k = 0; k < count; k++) { IGH_Param parameter2 = outputs[k].Parameter; GH_LinkedParamAttributes val2 = (GH_LinkedParamAttributes)parameter2.Attributes; FieldInfo field = typeof(GH_LinkedParamAttributes).GetField("m_renderTags", BindingFlags.Instance | BindingFlags.NonPublic); GH_StateTagList val3 = parameter2.StateTags; if (field != null) { if (((List <IGH_StateTag>)val3).Count == 0) { val3 = null; field.SetValue(val2, val3); } if (val3 != null) { Rectangle rectangle = GH_Convert.ToRectangle(val2.Bounds); rectangle.Width -= num2; val3.Layout(rectangle, GH_StateTagLayoutDirection.Right); rectangle = val3.BoundingBox; if (!rectangle.IsEmpty) { val2.Bounds = (RectangleF.Union(val2.Bounds, rectangle)); } field.SetValue(val2, val3); } } if (!expanded) { val2.Bounds = (new RectangleF(val2.Bounds.X + val2.Bounds.Width - 5f, val2.Bounds.Y, 5f, val2.Bounds.Height)); } } } num3 += composedCollection.Menus[i].TotalHeight; } }
public EvaluationUnitManager(GH_SwitcherComponent component) { units = new List <EvaluationUnit>(); this.component = component; }