/// <summary>
/// Override of the render for create the spiner over the component
/// </summary>
/// <param name="iCanvas"> GH_Canvas: is the control handles all mouse and paint event for a single loaded document.</param>
/// <param name="graphics"> Graphics: Encapsulates a GDI+ drawing surface. This class cannot be inherited.</param>
/// <param name="iChannel"> GH_CanvasChannel: Enumerates all the drawing channel that are handled inside the Grasshopper canvas.</param>
protected override void Render(GH_Canvas iCanvas, Graphics graphics, GH_CanvasChannel iChannel)
{
if ((iChannel == GH_CanvasChannel.Objects))
{
var pointer = new PointF(Bounds.Location.X, Bounds.Location.Y);
//render the sing of TDM Solutions
if ((iCanvas.Viewport.IsVisible(ref pointer, 5.0f)))
{
var pt = new PointF(0.5f * (Bounds.Left + Bounds.Right), Bounds.Top);
GH_GraphicsUtil.RenderBalloonTag(iCanvas.Graphics, "TDM solutions", pt,
iCanvas.Viewport.VisibleRegion);
}
//if it's working render the spiner
if (((RhinoNest)Owner).IsWorking)
{
var ptSpinner = new PointF(0.5f * (Bounds.Left + Bounds.Right), Bounds.Top);
graphics.DrawArc(new Pen(Color.SteelBlue, SPINNER_THICKNESS), ptSpinner.X - (SPINNER_SIZE / 2), ptSpinner.Y - (Bounds.Height / 2) - SPINNER_SIZE, SPINNER_SIZE, SPINNER_SIZE, 0, _spinnerAngle);
if (_spinnerAngle > 360) _spinnerAngle -= 360;
_spinnerAngle += 10.0f;
}
}
base.Render(iCanvas, graphics, iChannel);
}
protected override void Render(GH_Canvas canvas, System.Drawing.Graphics graphics, GH_CanvasChannel channel)
{
base.Render(canvas, graphics, channel);
if (channel == GH_CanvasChannel.Objects)
{
GH_Capsule button = GH_Capsule.CreateTextCapsule(ButtonBounds, ButtonBounds, GH_Palette.Black, "Param Refresh", 2, 0);
button.Render(graphics, Selected, Owner.Locked, false);
button.Dispose();
}
}
public override GH_ObjectResponse RespondToMouseDoubleClick(GH_Canvas sender, GH_CanvasMouseEvent e)
{
SetupPanel();
if (!panel.Visible)
{
panel.Show(GH_InstanceServer.DocumentEditor);
}
panel.UpdateComboBox();
panel.HSCombo.SelectedItem = m_owner;
return GH_ObjectResponse.Handled;
}
public override GH_ObjectResponse RespondToMouseDoubleClick(GH_Canvas sender, GH_CanvasMouseEvent e)
{
if (ContentBox.Contains(e.CanvasLocation))
{
IfcOpenInRevit component = Owner as IfcOpenInRevit;
System.Diagnostics.Debug.Write("double click called\n");
// Force the re-culculation of the component
component.ExpireSolution(true);
return GH_ObjectResponse.Handled;
}
return GH_ObjectResponse.Ignore;
}
public override GH_ObjectResponse RespondToMouseDown(GH_Canvas sender, GH_CanvasMouseEvent e)
{
if (e.Button == System.Windows.Forms.MouseButtons.Left)
{
System.Drawing.RectangleF rec = ButtonBounds;
if (rec.Contains(e.CanvasLocation))
{
MessageBox.Show("The button was clicked, and we want " + (base.Owner as VariableParameterTestComponent).outputparamno + " output params", "Button", MessageBoxButtons.OK);
(base.Owner as VariableParameterTestComponent).MatchParameterCount();
return GH_ObjectResponse.Handled;
}
}
return base.RespondToMouseDown(sender, e);
}
public override GH_ObjectResponse RespondToMouseDown(GH_Canvas sender, GH_CanvasMouseEvent e)
{
if (e.Button == System.Windows.Forms.MouseButtons.Left)
{
System.Drawing.RectangleF rec = ButtonBounds;
if (rec.Contains(e.CanvasLocation))
{
(base.Owner as HairwormComponent).InitCluster();
//MessageBox.Show("The button was clicked, and we want " + (base.Owner as HairwormComponent).clusterParamNumInput + " inputs and " + (base.Owner as HairwormComponent).clusterParamNumOutput + " output params", "Button", MessageBoxButtons.OK);
return GH_ObjectResponse.Handled;
}
}
return base.RespondToMouseDown(sender, e);
}
protected override void Render(GH_Canvas canvas, Graphics graphics, GH_CanvasChannel channel)
{
base.Render(canvas, graphics, channel);
var demBounds =
(RectangleF)
GH_Convert.ToRectangle(new RectangleF(new PointF(this.Pivot.X + 60, this.Pivot.Y),
(SizeF) new Size(W - 60 - 80, H)));
GH_Palette palette = GH_Palette.White;
GH_Capsule capsule = GH_Capsule.CreateCapsule(demBounds, palette);
capsule.Render(graphics, Selected, Owner.Locked, true);
capsule.Dispose();
capsule = null;
StringFormat format = new StringFormat();
format.Alignment = StringAlignment.Near;
format.LineAlignment = StringAlignment.Center;
format.Trimming = StringTrimming.EllipsisCharacter;
// Content rectangle
RectangleF textRectangle = demBounds;
textRectangle.Height = 20;
for (int i = 0; i < BimVisualiserData.Instance.NameList.Count; i++)
{
_boundingBoxes.Insert(i, textRectangle);
// Max entries value (it would be nice extending the Bounds if more)
if (i == 25)
break;
if (i == BimVisualiserData.Instance.Selected)
graphics.DrawString(BimVisualiserData.Instance.NameList[i], GH_FontServer.Standard,
Brushes.DodgerBlue, textRectangle, format);
else
graphics.DrawString(BimVisualiserData.Instance.NameList[i], GH_FontServer.Standard, Brushes.Black,
textRectangle, format);
format.Alignment = StringAlignment.Near;
//textRectangle.Inflate(-5, 0);
textRectangle.Y += 20;
}
// Always dispose of any GDI+ object that implement IDisposable.
format.Dispose();
}
protected override void RespondToMouseUp(GH_Canvas sender, GH_CanvasMouseEvent e)
{
if (e.Button == MouseButtons.Left)
{
if (_isToggle)
{
bool isNull;
bool value = !GetValue(out isNull);
SetValue(isNull ? true : value);
}
else
{
SetValue(false);
}
Owner.ExpireSolution(true);
}
base.RespondToMouseUp(sender, e);
}
protected override void Render(GH_Canvas canvas, Graphics graphics, GH_CanvasChannel channel)
{
base.Render(canvas, graphics, channel);
if (channel == GH_CanvasChannel.Objects)
{
GH_Capsule radio = GH_Capsule.CreateCapsule(radio_rec, GH_Palette.White, 2, 0);
radio.Render(graphics, Selected, Owner.Locked, false); radio.Dispose();
GH_Capsule radio_1 = GH_Capsule.CreateCapsule(radio_rec_1, GH_Palette.Black, 5, 5);
radio_1.Render(graphics, Selected, Owner.Locked, false); radio_1.Dispose();
graphics.FillEllipse(c1, radio_rec_1);
graphics.DrawString("Beam", GH_FontServer.Standard, Brushes.Black, text_rec_1);
GH_Capsule radio_2 = GH_Capsule.CreateCapsule(radio_rec_2, GH_Palette.Black, 5, 5);
radio_2.Render(graphics, Selected, Owner.Locked, false); radio_2.Dispose();
graphics.FillEllipse(c2, radio_rec_2);
graphics.DrawString("Shell(Tri)", GH_FontServer.Standard, Brushes.Black, text_rec_2);
}
}
protected override void Render(GH_Canvas canvas, Graphics graphics, GH_CanvasChannel channel)
{
if (channel == GH_CanvasChannel.Wires)
{
base.Render(canvas, graphics, channel);
}
if (channel == GH_CanvasChannel.Objects)
{
float ParamWidth = Setting.DROPDOWNCOMPONENTPARAMHEIGHT;
RectangleF ContentBox = new RectangleF(Bounds.Left + ParamWidth, Bounds.Top, this.Owner.Attributes.Bounds.Width - 2 * ParamWidth - Setting.DROPDOWNTRIANGLEHEIGHT - 10, Setting.DROPDOWNCOMPONENTHEIGHT);
base.AttributeUtil.RenderComponentBounds(graphics);
base.AttributeUtil.RenderParamsGripPoints1(graphics, canvas);
base.AttributeUtil.DrawHorizonComponentName(ContentBox, graphics, false);
this.DropDownControl.OnDraw(graphics);
this.DropDownControl.DrawLine(graphics);
}
}
public override GH_ObjectResponse RespondToMouseDown(GH_Canvas sender, GH_CanvasMouseEvent e)
{
if (unfolded)
{
if (e.Button == System.Windows.Forms.MouseButtons.Left)
{
System.Drawing.RectangleF rec = scrollBar;
GH_Component comp = Owner as GH_Component;
if (rec.Contains(e.CanvasLocation))
{
dragMouseStartY = e.CanvasLocation.Y;
drag = true;
comp.ExpireSolution(true);
return(GH_ObjectResponse.Capture);
}
}
}
return(base.RespondToMouseDown(sender, e));
}
/// <summary>
/// Render the component
/// </summary>
/// <param name="canvas"></param>
/// <param name="graphics"></param>
/// <param name="channel"></param>
protected override void Render(GH_Canvas canvas, Graphics graphics, GH_CanvasChannel channel)
{
Grasshopper.GUI.Canvas.GH_PaletteStyle styleStandard = null;
if (channel == GH_CanvasChannel.Objects)
{
// Cache the current styles.
styleStandard = GH_Skin.palette_normal_standard;
GH_Skin.palette_normal_standard = new GH_PaletteStyle(Color.FromArgb(255, 13, 138), Color.Black, Color.Black);
}
base.Render(canvas, graphics, channel);
if (channel == GH_CanvasChannel.Objects)
{
// Restore the cached styles.
GH_Skin.palette_normal_standard = styleStandard;
}
}
public override GH_ObjectResponse RespondToMouseDown(GH_Canvas sender, GH_CanvasMouseEvent e)
{
if (_headBounds.Contains(e.CanvasLocation))
{
if (Expanded)
{
_activeControl = null;
}
_expanded = !_expanded;
Layout(); //daq =)
return(GH_ObjectResponse.Handled);
}
if (_expanded)
{
if (_contentBounds.Contains(e.CanvasLocation))
{
for (int i = 0; i < inputs.Count; i++)
{
if (inputs[i].Parameter.Attributes.Bounds.Contains(e.CanvasLocation))
{
return(inputs[i].Parameter.Attributes.RespondToMouseDown(sender, e));
}
}
for (int j = 0; j < _controls.Count; j++)
{
if (_controls[j].Contains(e.CanvasLocation))
{
_activeControl = _controls[j];
return(_controls[j].RespondToMouseDown(sender, e));
}
}
}
else if (_activeControl != null)
{
_activeControl.RespondToMouseDown(sender, e);
_activeControl = null;
return(GH_ObjectResponse.Handled);
}
}
return(0);
}
public override GH_ObjectResponse RespondToMouseMove(GH_Canvas sender, GH_CanvasMouseEvent e)
{
if (drag)
{
GH_Component comp = Owner as GH_Component;
deltaY = e.CanvasLocation.Y - dragMouseStartY;
comp.ExpireSolution(true);
return(GH_ObjectResponse.Ignore);
}
if (taperBounds.Contains(e.CanvasLocation) |
hollowBounds.Contains(e.CanvasLocation) |
ellipBounds.Contains(e.CanvasLocation) |
genBounds.Contains(e.CanvasLocation) |
b2bBounds.Contains(e.CanvasLocation) |
inclSsBounds.Contains(e.CanvasLocation))
{
mouseOver = true;
sender.Cursor = System.Windows.Forms.Cursors.Hand;
return(GH_ObjectResponse.Capture);
}
for (int i = 0; i < ButtonBound.Count; i++)
{
if (ButtonBound[i].Contains(e.CanvasLocation))
{
mouseOver = true;
sender.Cursor = System.Windows.Forms.Cursors.Hand;
return(GH_ObjectResponse.Capture);
}
}
if (mouseOver)
{
mouseOver = false;
Grasshopper.Instances.CursorServer.ResetCursor(sender);
return(GH_ObjectResponse.Release);
}
return(base.RespondToMouseMove(sender, e));
}
protected override void Render(GH_Canvas canvas, System.Drawing.Graphics graphics, GH_CanvasChannel channel)
{
base.Render(canvas, graphics, channel);
if (channel == GH_CanvasChannel.Objects)
{
GH_Capsule button1 = GH_Capsule.CreateTextCapsule(Button1Bounds, Button1Bounds, GH_Palette.Black, "Build Model", 2, 0);
button1.Render(graphics, Selected, Owner.Locked, false);
button1.Dispose();
GH_Capsule button2 = GH_Capsule.CreateTextCapsule(Button2Bounds, Button2Bounds, GH_Palette.Black, "Update PDs", 2, 0);
button2.Render(graphics, Selected, Owner.Locked, false);
button2.Dispose();
GH_Capsule button3 = GH_Capsule.CreateTextCapsule(Button3Bounds, Button3Bounds, GH_Palette.Black, "Reset All PDs", 2, 0);
button3.Render(graphics, Selected, Owner.Locked, false);
button3.Dispose();
}
}
protected override void Render(GH_Canvas canvas, System.Drawing.Graphics graphics, GH_CanvasChannel channel)
{
base.Render(canvas, graphics, channel);
if (channel == GH_CanvasChannel.Objects)
{
GH_Capsule button;
if (((SelectComponent)Owner).inputLock)
{
button = GH_Capsule.CreateTextCapsule(ButtonBounds, ButtonBounds, GH_Palette.Black, "Locked", 2, 0);
}
else
{
button = GH_Capsule.CreateTextCapsule(ButtonBounds, ButtonBounds, GH_Palette.Black, "Select", 2, 0);
}
button.Render(graphics, Selected, Owner.Locked, false);
button.Dispose();
}
}
internal override GH_ObjectResponse RespondToMouseUp(GH_Canvas sender, GH_CanvasMouseEvent e)
{
var pt = e.CanvasLocation;
if (OnButton(pt) && pressed)
{
pressed = false;
OnClick();
TriggerRedraw();
return(GH_ObjectResponse.Release);
}
if (pressed) //mouse held down then moved off button
{
pressed = false;
TriggerRedraw();
return(GH_ObjectResponse.Release);
}
return(GH_ObjectResponse.Ignore);
}
/// <summary>
/// Event of Double Click for the left button
/// </summary>
/// <param name="sender"> GH_Canvas: is the control handles all mouse and paint event for a single loaded document.</param>
/// <param name="e"> GH_CanvasMouseEvent: Class used in UI events.</param>
/// <returns></returns>
public override GH_ObjectResponse RespondToMouseDoubleClick(GH_Canvas sender, GH_CanvasMouseEvent e)
{
if (e.Button == MouseButtons.Left)
{
try
{
if (((RhinoNest)Owner).IsWorking == false)
{
((RhinoNest)Owner)._mSolveme = true;
Owner.ExpireSolution(true);
}
}
finally
{
((RhinoNest)Owner)._mSolveme = false;
}
}
return base.RespondToMouseDoubleClick(sender, e);
}
/// <summary>
/// Event of Double Click for the left button
/// </summary>
/// <param name="sender"> GH_Canvas: is the control handles all mouse and paint event for a single loaded document.</param>
/// <param name="e"> GH_CanvasMouseEvent: Class used in UI events.</param>
/// <returns></returns>
public override GH_ObjectResponse RespondToMouseDoubleClick(GH_Canvas sender, GH_CanvasMouseEvent e)
{
if (e.Button == MouseButtons.Left)
{
try
{
if (((RhinoNest)Owner).IsWorking == false)
{
((RhinoNest)Owner)._mSolveme = true;
Owner.ExpireSolution(true);
}
}
finally
{
((RhinoNest)Owner)._mSolveme = false;
}
}
return(base.RespondToMouseDoubleClick(sender, e));
}
/// <summary>
/// change the right click.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
protected override void RespondToMouseUp(GH_Canvas sender, GH_CanvasMouseEvent e)
{
if (e.Button == MouseButtons.Right && CreateMenu != null)
{
var menu = CreateMenu();
if (UnableMenu)
{
foreach (var item in menu.Items)
{
if (item is ToolStripItem)
{
ToolStripItem toolStrip = item as ToolStripItem;
toolStrip.Enabled = false;
}
}
}
menu.Show(sender, e.ControlLocation);
}
}
protected override void Render(GH_Canvas canvas, System.Drawing.Graphics graphics, GH_CanvasChannel channel)
{
base.Render(canvas, graphics, channel);
if (channel == GH_CanvasChannel.Objects)
{
//GH_Capsule button = GH_Capsule.CreateTextCapsule(ButtonBounds, ButtonBounds, GH_Palette.Black, "Button", 2, 0);
//button.Render(graphics, Selected, Owner.Locked, false);
//button.Dispose();
for (int i = 0; i < _selected.Length; i++)
{
DrawRadioButton(graphics, new PointF(_recList[i].Left + 5, _recList[i].Bottom - 5), _selected[i]);
DrawString(graphics, new PointF(_recList[i].Left - 4, _recList[i].Bottom - 24), texts[i]);
}
}
}
public override GH_ObjectResponse RespondToMouseDown(GH_Canvas sender, GH_CanvasMouseEvent e)
{
if (e.Button == System.Windows.Forms.MouseButtons.Left)
{
System.Drawing.RectangleF rec = BorderBound;
GH_Component comp = Owner as GH_Component;
if (rec.Contains(e.CanvasLocation))
{
unfolded = !unfolded;
comp.ExpireSolution(true);
return(GH_ObjectResponse.Handled);
}
if (unfolded)
{
System.Drawing.RectangleF rec2 = dropdownBound;
if (rec2.Contains(e.CanvasLocation))
{
for (int i = 0; i < dropdownlist.Count; i++)
{
System.Drawing.RectangleF rec3 = dropdownBounds[i];
if (rec3.Contains(e.CanvasLocation))
{
comp.RecordUndoEvent("Selected " + dropdownlist[i]);
displayText = dropdownlist[i]; //change what user sees to selected item
action(dropdownlist[i]); // send selected item back to component
unfolded = !unfolded; // close dropdown
comp.ExpireSolution(true);
return(GH_ObjectResponse.Handled);
}
}
}
else
{
unfolded = !unfolded;
comp.ExpireSolution(true);
return(GH_ObjectResponse.Handled);
}
}
}
return(base.RespondToMouseDown(sender, e));
}
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 override GH_ObjectResponse RespondToMouseMove(GH_Canvas sender, GH_CanvasMouseEvent e)
{
if (Button1Bounds.Contains(e.CanvasLocation))
{
mouseOver1 = true;
mouseOver2 = false;
mouseOver3 = false;
Owner.OnDisplayExpired(false);
sender.Cursor = System.Windows.Forms.Cursors.Hand;
return(GH_ObjectResponse.Capture);
}
if (Button2Bounds.Contains(e.CanvasLocation))
{
mouseOver2 = true;
mouseOver1 = false;
mouseOver3 = false;
Owner.OnDisplayExpired(false);
sender.Cursor = System.Windows.Forms.Cursors.Hand;
return(GH_ObjectResponse.Capture);
}
if (Button3Bounds.Contains(e.CanvasLocation))
{
mouseOver3 = true;
mouseOver1 = false;
mouseOver2 = false;
Owner.OnDisplayExpired(false);
sender.Cursor = System.Windows.Forms.Cursors.Hand;
return(GH_ObjectResponse.Capture);
}
if (mouseOver1 | mouseOver2 | mouseOver3)
{
mouseOver1 = false;
mouseOver2 = false;
mouseOver3 = false;
Owner.OnDisplayExpired(false);
Grasshopper.Instances.CursorServer.ResetCursor(sender);
return(GH_ObjectResponse.Release);
}
return(base.RespondToMouseMove(sender, e));
}
public void AppendGGitBtn(GH_Canvas canvas)
{
if (_btnAdded)
{
return;
}
foreach (Control control in DocumentEditor.Controls)
{
StatusStrip ss = control as StatusStrip;
if (ss != null)
{
ToolStripMenuItem gitBtn = new ToolStripMenuItem(null, Properties.Resources.icons8_git_16_green);
ToolStripStatusLabel status = new ToolStripStatusLabel("git status");
gitBtn.DropDown.Items.Add(status);
ss.Items.Add(gitBtn);
return;
}
}
_btnAdded = true;
}
/// <summary>
/// finds the children in which the cursor is inside and then call the MouseOver method for that child
/// </summary>
/// <param name="gHContainer"></param>
/// <param name="customComponent"></param>
/// <param name="e"></param>
/// <param name="result"></param>
public static void MouseOverChildren(this IGHPanel gHContainer, GH_Canvas sender, GHCustomComponent customComponent, GH_CanvasMouseEvent e, ref GHMouseEventResult result)
{
foreach (GHControl control in gHContainer.Items)
{
if (control.Bounds.Contains(e.CanvasLocation) && control.Enabled)
{
control.MouseOver(sender, customComponent, e, ref result);
if (result.HasFlag(GHMouseEventResult.Invalidated)) // no need to continue as this child already set the flag
{
return;
}
}
else
{
control.MouseLeave(sender, customComponent, e, ref result);
//if (result.HasFlag(GHMouseEventResult.Invalidated)) // no need to continue as this child already set the flag
// return;
}
}
}
public override GH_ObjectResponse RespondToMouseUp(GH_Canvas sender, GH_CanvasMouseEvent e)
{
if (e.Button == System.Windows.Forms.MouseButtons.Left)
{
System.Drawing.RectangleF rec = ButtonBounds;
if (rec.Contains(e.CanvasLocation))
{
if (mouseDown)
{
mouseDown = false;
mouseOver = false;
Owner.OnDisplayExpired(false);
action();
// Owner.ExpireSolution(true);
return(GH_ObjectResponse.Release);
}
}
}
return(base.RespondToMouseUp(sender, e));
}
public override GH_ObjectResponse RespondToMouseUp(GH_Canvas sender, GH_CanvasMouseEvent e)
{
if (e.Button == MouseButtons.Left)
{
if (_mouseDownElement != null)
{
var pt = new Point((int)e.CanvasLocation.X, (int)e.CanvasLocation.Y);
if (_mouseDownElement.Bounds.Contains(pt))
{
_mouseDownElement.InvokeAction();
}
_mouseDownElement.OnMouseUp();
_mouseDownElement = null;
Owner.OnDisplayExpired(true);
return(GH_ObjectResponse.Release);
}
}
return(base.RespondToMouseUp(sender, e));
}
public override GH_ObjectResponse RespondToMouseDoubleClick(GH_Canvas sender, GH_CanvasMouseEvent e)
{
if (base.Owner.Graph == null)
{
return((GH_ObjectResponse)3);
}
GH_GraphEditor val = new GH_GraphEditor();
val.SetGraph(base.Owner.Container);
GH_WindowsFormUtil.CenterFormOnCursor((Form)(object)val, true);
DialogResult dialogResult = val.ShowDialog(Instances.DocumentEditor);
if (dialogResult == DialogResult.OK)
{
val.Graph.LockGrips = base.Owner.Container.LockGrips;
base.Owner.Container = val.Graph;
}
((Component)(object)val).Dispose();
return((GH_ObjectResponse)3);
}
protected override void Render(GH_Canvas canvas, Graphics graphics, GH_CanvasChannel channel)
{
if (channel != GH_CanvasChannel.Objects)
{
base.Render(canvas, graphics, channel);
}
else
{
RenderComponentCapsule(canvas, graphics, true, false, false, true, false, false);
var rectangle1 = GH_Convert.ToRectangle(m_innerBounds);
if (GH_Canvas.ZoomFadeLow > 0)
{
graphics.DrawImage(CanvasImage, imagefarame);
}
if (GH_Canvas.ZoomFadeLow < .67)
{
graphics.DrawImage(Runway.Properties.Resources.RunwayImage, imagefarame);
}
}
}
public override GH_ObjectResponse RespondToMouseDoubleClick(GH_Canvas sender, GH_CanvasMouseEvent e)
{
this.Bounds = baseRect;
if (Owner.Attributes.Bounds.Contains(e.CanvasLocation) && e.Button == System.Windows.Forms.MouseButtons.Left && sender.Viewport.Zoom >= 0.5f)
{
AdvancedOptions windowForm = new AdvancedOptions(Owner);
WindowInteropHelper ownerHelper = new WindowInteropHelper(windowForm);
ownerHelper.Owner = Grasshopper.Instances.DocumentEditor.Handle;
windowForm.Show();
return(GH_ObjectResponse.Release);
}
GH_ObjectResponse result = base.RespondToMouseDoubleClick(sender, e);
this.Bounds = thisRect;
return(result);
}
public override GH_ObjectResponse RespondToMouseDown(GH_Canvas sender, GH_CanvasMouseEvent e)
{
if (e.Button == System.Windows.Forms.MouseButtons.Left)
{
var component = Owner as Generator;
if (((System.Drawing.RectangleF)CapsuleBounds[1]).Contains(e.CanvasLocation))
{
component.PrintLabel = !component.PrintLabel;
component.ForceRecalc = true;
component.ExpireSolution(true);
return(GH_ObjectResponse.Handled);
}
else if (((System.Drawing.RectangleF)CapsuleBounds[2]).Contains(e.CanvasLocation))
{
component.Collision = !component.Collision;
component.ExpireSolution(true);
return(GH_ObjectResponse.Handled);
}
else if (((System.Drawing.RectangleF)CapsuleBounds[4]).Contains(e.CanvasLocation))
{
component.AnnotateRods = !component.AnnotateRods;
component.ExpireSolution(true);
return(GH_ObjectResponse.Handled);
}
else if (((System.Drawing.RectangleF)CapsuleBounds[5]).Contains(e.CanvasLocation))
{
component.AnnotateJoints = !component.AnnotateJoints;
component.ExpireSolution(true);
return(GH_ObjectResponse.Handled);
}
else if (((System.Drawing.RectangleF)CapsuleBounds[6]).Contains(e.CanvasLocation))
{
component.AnnotateJointArms = !component.AnnotateJointArms;
component.ExpireSolution(true);
return(GH_ObjectResponse.Handled);
}
}
return(base.RespondToMouseDown(sender, e));
}
private void LoadGhDocument(string file)
{
if (!System.IO.File.Exists(file))
{
return;
}
GH_DocumentIO io = new GH_DocumentIO();
io.Open(file);
GH_Document doc = GH_Document.DuplicateDocument(io.Document);
if (doc == null)
{
return;
}
GH_DocumentServer server = Instances.DocumentServer;
if (server == null)
{
return;
}
server.AddDocument(doc);
doc.Properties.ProjectFileName = ID.ToString();
GH_Canvas activeCanvas = Instances.ActiveCanvas;
if (activeCanvas == null)
{
return;
}
activeCanvas.Document = doc;
activeCanvas.Document.IsModified = false;
activeCanvas.Refresh();
doc.SolutionEnd += Doc_SolutionEnd;
}
protected override void Render(GH_Canvas canvas, Graphics graphics, GH_CanvasChannel channel)
{
if (channel == GH_CanvasChannel.Objects)
{
//Render output grip.
GH_CapsuleRenderEngine.RenderOutputGrip(graphics, canvas.Viewport.Zoom, OutputGrip, true);
//Render capsules.
for (int col = 0; col < 3; col++)
{
Rectangle button = Button(col);
GH_Capsule capsule = Value(col) ?
GH_Capsule.CreateTextCapsule(button, button, palWhite, "1", 0, 0)
:
GH_Capsule.CreateTextCapsule(button, button, palBlack, "0", 0, 0);
capsule.Render(graphics, Selected, Owner.Locked, false);
capsule.Dispose();
}
}
}
internal override void MouseRightClick(GH_Canvas sender, GHCustomComponent customComponent, GH_CanvasMouseEvent e, ref GHMouseEventResult result)
{
base.MouseRightClick(sender, customComponent, e, ref result);
if (result.HasFlag(GHMouseEventResult.Handled))
{
return;
}
decimal d = Convert.ToDecimal(CurrentValue);
NumericUpDownData <decimal> numeric = new NumericUpDownData <decimal>(d, Convert.ToDecimal(_min), Convert.ToDecimal(_max), FormatString);
if (numeric.GetInput(PointToScreen(sender, Pos), out decimal val))
{
CurrentValue = (float)val;
result = result | GHMouseEventResult.UpdateSolution | GHMouseEventResult.Handled;
}
else
{
result = result | GHMouseEventResult.Handled;
}
showLabel = true;
}
public override GH_ObjectResponse RespondToMouseDoubleClick(GH_Canvas sender, GH_CanvasMouseEvent e)
{
PointF canvasPivot = base.CanvasPivot;
if (_headBounds.Contains(e.CanvasLocation))
{
return(GH_ObjectResponse.Handled);
}
if (_expanded && _contentBounds.Contains(e.CanvasLocation))
{
int count = _controls.Count;
for (int i = 0; i < count; i++)
{
if (_controls[i].Contains(e.CanvasLocation))
{
return(_controls[i].RespondToMouseDoubleClick(sender, e));
}
}
}
return(0);
}
protected override void Render(GH_Canvas canvas, Graphics graphics, GH_CanvasChannel channel)
{
base.Render(canvas, graphics, channel);
if (channel == GH_CanvasChannel.Objects)
{
float width = 200;
float width2 = 120;
float height = Bounds.Height;
float margin = 8;
float spacing = GH_FontServer.StandardBold.GetHeight() * 1.05f;
float left = Pivot.X - (width - 50) + margin;
float top = Pivot.Y - height / 2 + margin;
graphics.FillRectangle(new SolidBrush(Color.FromArgb(30, 38, 42)), new RectangleF(new PointF(left, top), new SizeF(width2, height - margin * 2)));
graphics.DrawString("URI:", GH_FontServer.StandardBold, Brushes.LightGray, new PointF(left + margin, top + margin));
if (((SOMFLUXCOMMUNICATION)Owner).myControlPanel != null)
{
graphics.DrawString(((SOMFLUXCOMMUNICATION)Owner).path.Replace("net.pipe:", ""), GH_FontServer.StandardBold, Brushes.White, new PointF(left + margin, top + margin + spacing));
}
}
}
public override GH_ObjectResponse RespondToMouseDown(GH_Canvas sender, GH_CanvasMouseEvent e)
{
if (e.Button == MouseButtons.Left)
{
RectangleF rec1 = radio_rec1_1;
if (rec1.Contains(e.CanvasLocation))
{
if (c1 == Brushes.White)
{
c1 = Brushes.Black; SetButton("1", 1);
}
else
{
c1 = Brushes.White; SetButton("1", 0);
}
Owner.ExpireSolution(true);
return(GH_ObjectResponse.Handled);
}
}
return(base.RespondToMouseDown(sender, e));
}
protected override void Render(GH_Canvas canvas, Graphics graphics, GH_CanvasChannel channel)
{
if (channel == GH_CanvasChannel.Wires)
{
base.Render(canvas, graphics, channel);
Layout();
}
if (channel == GH_CanvasChannel.Objects)
{
//debug
/*
//base.Render(canvas, graphics, channel);
graphics.DrawRectangle(new Pen(Color.Yellow, 3f), GH_Convert.ToRectangle(Bounds));
graphics.DrawRectangle(new Pen(Color.Blue, 2f), GH_Convert.ToRectangle(componentBox));
foreach (var param in Owner.Params.Input)
{
graphics.DrawRectangle(new Pen(Color.Green, 2f), GH_Convert.ToRectangle(param.Attributes.Bounds));
}
foreach (var param in Owner.Params.Output)
{
graphics.DrawRectangle(new Pen(Color.Green, 2f), GH_Convert.ToRectangle(param.Attributes.Bounds));
}
graphics.DrawRectangle(new Pen(Color.Red, 2f), new Rectangle((int)(Bounds.X), (int)(Bounds.Y), (int)(Bounds.Width), (int)(titleheight)));
*/
//background
if (Owner.Attributes.Selected) graphics.FillRectangle(new SolidBrush(bgcolour_selected), Bounds);
else graphics.FillRectangle(new SolidBrush(bgcolour), Bounds);
//title
graphics.FillRectangle(new SolidBrush(titlebgcolour), titleBox);
float titlewidth = GH_FontServer.StringWidth(Owner.Name, titlefont);
graphics.DrawString(Owner.Name, titlefont, Brushes.White, new PointF((float)(titleBox.Left + 0.5 * titleBox.Width - 0.5 * titlewidth), titleBox.Top));
//params
foreach (var param in Owner.Params.Input)
{
graphics.FillRectangle(new SolidBrush(parambgcolour), param.Attributes.Bounds);
graphics.DrawString(param.Name, paramfont, new SolidBrush(paramfontcolour), new PointF(param.Attributes.Bounds.X, param.Attributes.Bounds.Y + parammargin));
}
//params
foreach (var param in Owner.Params.Output)
{
graphics.FillRectangle(new SolidBrush(parambgcolour), param.Attributes.Bounds);
int textwidth = GH_FontServer.StringWidth(param.Name, paramfont);
graphics.DrawString(param.Name, paramfont, new SolidBrush(paramfontcolour), new PointF(param.Attributes.Bounds.X, param.Attributes.Bounds.Y + parammargin));
}
//message
graphics.DrawString(Owner.Message, messagefont, Brushes.Gray, componentBox.Location);
}
}
protected override void Render(GH_Canvas canvas, Graphics graphics, GH_CanvasChannel channel)
{
base.Render(canvas, graphics, channel);
}
public override GH_ObjectResponse RespondToMouseDoubleClick(GH_Canvas sender, GH_CanvasMouseEvent e)
{
OpenEditor();
return base.RespondToMouseDoubleClick(sender, e);
}
protected override void Render(GH_Canvas canvas, System.Drawing.Graphics graphics, GH_CanvasChannel channel)
{
base.Render(canvas, graphics, channel);
if (channel == GH_CanvasChannel.Objects)
{
/* //okay, so let's render the background
RectangleF capsuleBox = new RectangleF(this.Bounds.Location, this.Bounds.Size);
GH_Capsule capsule = GH_Capsule.CreateCapsule(capsuleBox, GH_Palette.Normal);
// but when we have a warning, change colors appropriately
if (Owner.RuntimeMessageLevel == GH_RuntimeMessageLevel.Error ||
Owner.RuntimeMessageLevel == GH_RuntimeMessageLevel.Warning)
{
capsule.Render(graphics, this.Selected, Owner.Locked, true);
}
else
{
capsule.Render(graphics, Color.FromArgb(188, 157, 202));
}
capsule.Dispose();
*/
button = GH_Capsule.CreateTextCapsule(ButtonBounds, ButtonBounds, GH_Palette.Pink, "(Re)load Cluster", 2, 0);
button.Render(graphics, Selected, Owner.Locked, false);
button.Dispose();
}
}
/*
public override void ExpireLayout()
{
base.ExpireLayout();
//手动释放layout 和layout写在一起
}
protected override void Layout()
{
//初始化
this.m_innerBounds = new RectangleF(this.Pivot, new SizeF(100f, 100f));
LayoutInputParams(this.Owner, this.m_innerBounds);
LayoutOutputParams(this.Owner, this.m_innerBounds);
this.Bounds = LayoutBounds(this.Owner, this.m_innerBounds);
}
*/
//决定电池显示内容的。可以在这里修改决定是否显示物体
protected override void Render(GH_Canvas canvas, Graphics graphics, GH_CanvasChannel channel)
{
if (channel == GH_CanvasChannel.Wires)
{
base.Render(canvas, graphics, channel);
// 显示连线的，可以修改,默认设置如上
}
if (channel == GH_CanvasChannel.Objects)
{
//修改显示电池主体的代码
SolidBrush brush=new SolidBrush(Color.White);
SolidBrush brush2 = new SolidBrush(Color.White);
Pen pen = new Pen(Color.Black); Pen pen2 = new Pen(Color.Black);
pen.Width = 2;
switch (Owner.RuntimeMessageLevel)
{
case GH_RuntimeMessageLevel.Warning:
brush2.Color = Color.Orange;
break;
case GH_RuntimeMessageLevel.Error:
brush2.Color = Color.Red;
break;
case GH_RuntimeMessageLevel.Blank:
brush2.Color = Color.White;
break;
}
//graphics.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.HighQuality;
GH_Structure<GH_String> volatileData = (GH_Structure<GH_String>)base.Owner.Params.Input[0].VolatileData;
foreach (IGH_Param param in this.Owner.Params.Input)
{
graphics.FillEllipse(brush, param.Attributes.InputGrip.X - 6.2f, param.Attributes.InputGrip.Y - 4f, 8f, 8f);
graphics.DrawEllipse(pen, param.Attributes.InputGrip.X - 6.2f, param.Attributes.InputGrip.Y - 4f, 8f, 8f);
}
if (!volatileData.IsEmpty)
{
Bitmap bitmap;
string myPath = volatileData.get_DataItem(0).Value;
try
{
bitmap = new Bitmap(myPath);
}
catch
{
base.Owner.AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "Path must be a valid location");
brush2.Color = Color.Red;
graphics.FillRectangle(brush2, Rectangle.Round(this.Bounds));
graphics.DrawRectangle(pen2, Rectangle.Round(this.Bounds));
return;
}
this.Bounds = new RectangleF(new PointF(this.Bounds.Location.X, this.Bounds.Location.Y), new SizeF(bitmap.Size.Width-1f, bitmap.Size.Height-1f));
graphics.DrawImage(bitmap, new RectangleF(new PointF(this.Bounds.Location.X, this.Bounds.Location.Y), new SizeF(bitmap.Size.Width, bitmap.Size.Height)));
graphics.DrawRectangle(pen2, Rectangle.Round(this.Bounds));
bitmap.Dispose();
}
else
{
graphics.FillRectangle(brush2, Rectangle.Round(this.Bounds));
graphics.DrawRectangle(pen2, Rectangle.Round(this.Bounds));
}
}
}
protected override void Render(GH_Canvas canvas, System.Drawing.Graphics graphics, GH_CanvasChannel channel)
{
base.Render(canvas, graphics, channel);
if (m_form == null || m_form.IsDisposed) return;
if (channel == GH_CanvasChannel.Overlay &&
(canvas.DrawingMode == GH_CanvasMode.Export ||
canvas.DrawingMode == GH_CanvasMode.Control)
)
{
Rectangle targetRectangle;
if (canvas.DrawingMode == GH_CanvasMode.Export)
{
System.Windows.Forms.Control editorControl = m_form.m_texteditor;
if (editorControl == null) return;
targetRectangle = editorControl.ClientRectangle;
targetRectangle = m_form.RectangleToScreen(targetRectangle);
}
else
{
targetRectangle = m_form.DesktopBounds;
}
RectangleF windowOnCanvas;
{
targetRectangle.Inflate(-1, -1);
var desktopForm = canvas.RectangleToClient(targetRectangle);
windowOnCanvas = canvas.Viewport.UnprojectRectangle(desktopForm);
}
var transparent = Color.Transparent;
var desk_tl = new PointF(windowOnCanvas.Left, windowOnCanvas.Top);
var desk_tr = new PointF(windowOnCanvas.Right, windowOnCanvas.Top);
var desk_bl = new PointF(windowOnCanvas.Left, windowOnCanvas.Bottom);
var desk_br = new PointF(windowOnCanvas.Right, windowOnCanvas.Bottom);
var comp_tl = new PointF(Bounds.Left, Bounds.Top);
var comp_tr = new PointF(Bounds.Right, Bounds.Top);
var comp_bl = new PointF(Bounds.Left, Bounds.Bottom);
var comp_br = new PointF(Bounds.Right, Bounds.Bottom);
if (Bounds.Top < windowOnCanvas.Top)
BoxSide(graphics, Color.FromArgb(155,255,255,255), transparent, desk_tl, desk_tr, comp_tl, comp_tr);
if (Bounds.Right > windowOnCanvas.Right)
BoxSide(graphics, Color.FromArgb(155, 240, 240, 240), transparent, desk_tr, desk_br, comp_tr, comp_br);
if (Bounds.Bottom > windowOnCanvas.Bottom)
BoxSide(graphics, Color.FromArgb(155, 120, 120, 120), transparent, desk_bl, desk_br, comp_bl, comp_br);
if (Bounds.Left < windowOnCanvas.Left)
BoxSide(graphics, Color.FromArgb(155, 240, 240, 240), transparent, desk_tl, desk_bl, comp_tl, comp_bl);
BoxEdge(graphics, Color.Black, Color.Transparent, 1, desk_tl, comp_tl, AnchorStyles.Top | AnchorStyles.Left);
BoxEdge(graphics, Color.Black, Color.Transparent, 1, desk_tr, comp_tr, AnchorStyles.Top | AnchorStyles.Right);
BoxEdge(graphics, Color.Black, Color.Transparent, 1, desk_br, comp_br, AnchorStyles.Bottom | AnchorStyles.Right);
BoxEdge(graphics, Color.Black, Color.Transparent, 1, desk_bl, comp_bl, AnchorStyles.Bottom | AnchorStyles.Left);
if (canvas.DrawingMode == GH_CanvasMode.Export)
{
System.Windows.Forms.Control editorControl = m_form.m_texteditor;
if (editorControl == null) return;
using (var bitmap = new Bitmap(editorControl.Width, editorControl.Height))
{
editorControl.DrawToBitmap(bitmap, editorControl.Bounds);
var ot = graphics.Transform;
var loc = canvas.Viewport.ProjectPoint(windowOnCanvas.Location);
graphics.ResetTransform();
graphics.DrawImage(bitmap,
(int)loc.X, (int)loc.Y,
editorControl.Width, editorControl.Height);
graphics.Transform = ot;
}
}
}
}
public override GH_ObjectResponse RespondToMouseDoubleClick(GH_Canvas sender, GH_CanvasMouseEvent e)
{
for (int i = 0; i < _boundingBoxes.Count; i++)
{
if (_boundingBoxes[i].Contains(e.CanvasLocation))
{
BimVisualiserData.Instance.Selected = i;
_component.setReturnValue(BimVisualiserData.Instance.Selected);
_component.ExpirePreview(true);
_component.ExpireSolution(true);
return GH_ObjectResponse.Handled;
}
}
BimVisualiserData.Instance.Selected = -1;
return GH_ObjectResponse.Handled;
}
public override GH_ObjectResponse RespondToMouseDoubleClick(GH_Canvas sender, GH_CanvasMouseEvent e)
{
((SettingsComponent)Owner).ShowSettingsGui();
return GH_ObjectResponse.Handled;
}
protected override void Render(GH_Canvas canvas, Graphics graphics, GH_CanvasChannel channel)
{
// Render all the wires that connect the Owner to all its Sources.
if (channel == GH_CanvasChannel.Wires) base.Render(canvas, graphics, channel);
// Render the parameter capsule and any additional text on top of it.
if (channel == GH_CanvasChannel.Objects)
{
Dhr_HeatmapComponent realOwner = (Dhr_HeatmapComponent)Owner;
// Define the default palette.
GH_Palette palette = GH_Palette.Normal;
switch (Owner.RuntimeMessageLevel)
{
case GH_RuntimeMessageLevel.Warning:
palette = GH_Palette.Warning;
break;
case GH_RuntimeMessageLevel.Error:
palette = GH_Palette.Error;
break;
}
// Create a new Capsule without text or icon.
GH_Capsule capsulein = GH_Capsule.CreateCapsule(new RectangleF(Bounds.X, Bounds.Y, param_size.Width, Bounds.Height), palette, new int[] { 6, 2, 2, 6 }, 5);
GH_Capsule capsuleout = GH_Capsule.CreateCapsule(new RectangleF(Bounds.X + Bounds.Width - param_size.Width, Bounds.Y, param_size.Width, Bounds.Height), palette, new int[] { 2, 6, 6, 2 }, 5);
foreach (IGH_Param p in Owner.Params.Input) capsulein.AddInputGrip(p.Attributes.InputGrip.Y);
foreach (IGH_Param p in Owner.Params.Output) capsuleout.AddOutputGrip(p.Attributes.OutputGrip.Y);
capsulein.Render(graphics, Selected, Owner.Locked, true);
capsuleout.Render(graphics, Selected, Owner.Locked, true);
capsulein.Dispose();
capsuleout.Dispose();
capsulein = null;
capsuleout = null;
// draw text labels for inputs and outputs
StringFormat format = new StringFormat
{
Alignment = StringAlignment.Center,
LineAlignment = StringAlignment.Center,
Trimming = StringTrimming.EllipsisCharacter
};
foreach (IGH_Param p in Owner.Params.Input) graphics.DrawString(p.NickName, GH_FontServer.Standard, Brushes.Black, p.Attributes.Bounds, format);
foreach (IGH_Param p in Owner.Params.Output) graphics.DrawString(p.NickName, GH_FontServer.Standard, Brushes.Black, p.Attributes.Bounds, format);
RectangleF imgBounds = new RectangleF(new PointF(Bounds.X + param_size.Width + buffer, Bounds.Y), img_size);
//Bitmap bmp = Properties.Resources.Component;
//if (realOwner.isPlotable) bmp = makeHeatmapImage(realOwner);
//graphics.DrawImage(bmp, imgBounds);
if (realOwner.isPlotable) drawHeatmapImage(realOwner, graphics, imgBounds);
else graphics.FillRectangle(new SolidBrush(Color.FromArgb(64, 255, 255, 255)), imgBounds);
// draw lines
//graphics.DrawLine(new Pen(Color.White), new PointF(imgBounds.Left, imgBounds.Top), new PointF(imgBounds.Right, imgBounds.Top));
//graphics.DrawLine(new Pen(Color.White), new PointF(imgBounds.Left, imgBounds.Bottom), new PointF(imgBounds.Right, imgBounds.Bottom));
}
}
