protected CustomLineCap GetClone(Pen pen, float size, bool startCap) { float endPoint; if (pen.Width * _designWidth < size) { endPoint = pen.Width == 0 ? 1 : size / pen.Width; } else { endPoint = _designWidth; } if (startCap) { endPoint = -endPoint; } GraphicsPath hPath = new GraphicsPath(); // Create the outline for our custom end cap. hPath.AddLine(new PointF(endPoint < 0 ? 0.5f : -0.5f, 0), new PointF(endPoint / 2, 0)); CustomLineCap clone = new CustomLineCap(null, hPath); // we set the stroke path only clone.SetStrokeCaps(LineCap.Flat, LineCap.Flat); return(clone); }
private CustomLineCap GetClone(Pen pen, float size) { float endPoint; endPoint = pen.Width == 0 ? 1 : size / pen.Width; endPoint /= 2; if (endPoint <= 0) { endPoint = 1e-3f; } var hPath = new GraphicsPath(); var r = endPoint / (2 * Math.Sin(_designAngle * (Math.PI / 180))); var b = r - r * Math.Cos(_designAngle * (Math.PI / 180)); var h = endPoint / 2; // Create the outline for our custom end cap. hPath.AddArc( (float)(-r - h), (float)(-b), (float)(2 * r), (float)(2 * r), (float)(-90 - _designAngle), (float)(2 * _designAngle)); hPath.AddArc( (float)(h - r), (float)(b - 1.999999 * r), (float)(2 * r), (float)(2 * r), (float)(90 + _designAngle), (float)(-2 * _designAngle)); var clone = new CustomLineCap(null, hPath); // we set the stroke path only clone.SetStrokeCaps(LineCap.Flat, LineCap.Flat); return(clone); }
private CustomLineCap GetClone(Pen pen, float size) { float endPoint; endPoint = pen.Width == 0 ? 1 : size / (pen.Width * 2) - 0.5f; if (endPoint < 0) { endPoint = 1e-3f; } var hPath = new GraphicsPath(); // Create the outline for our custom end cap. hPath.AddPolygon(new PointF[] { new PointF(endPoint, -endPoint), new PointF(endPoint, endPoint), new PointF(-endPoint, endPoint), new PointF(-endPoint, -endPoint), }); var clone = new CustomLineCap(null, hPath, LineCap.Flat, endPoint); // we set the stroke path only clone.SetStrokeCaps(LineCap.Flat, LineCap.Flat); return(clone); }
private CustomLineCap GetClone(Pen pen, float size) { float endPoint; endPoint = pen.Width == 0 ? 1 : size / (pen.Width); if (endPoint <= 0) { endPoint = 1e-3f; } float c = 0.8660254f; // 0.5 / Math.Tan(30°); float r = 1; // 0.5/Math.Sin(30°); var hPath = new GraphicsPath(); // Create the outline for our custom end cap. hPath.AddPolygon(new PointF[] { new PointF(0, -endPoint * 0.866f + r), new PointF(endPoint / 2 - c, -0.5f), new PointF(-endPoint / 2 + c, -0.5f), }); var clone = new CustomLineCap(null, hPath, LineCap.Flat, endPoint * 0.866f - r); // we set the stroke path only clone.SetStrokeCaps(LineCap.Flat, LineCap.Flat); return(clone); }
public void SetThenGetStrokeCaps_Success(LineCap startCap, LineCap endCap) { using (GraphicsPath strokePath = new GraphicsPath()) using (CustomLineCap customLineCap = new CustomLineCap(null, strokePath)) { customLineCap.SetStrokeCaps(startCap, endCap); customLineCap.GetStrokeCaps(out LineCap retrievedStartCap, out LineCap retrievedEndCap); Assert.Equal(startCap, retrievedStartCap); Assert.Equal(endCap, retrievedEndCap); } }
[InlineData(LineCap.Custom + 1, LineCap.Flat)] // Above valid enum range public void SetStrokeCaps_InvalidLineCap_ThrowsArgumentException(LineCap startCap, LineCap endCap) { using (GraphicsPath strokePath = new GraphicsPath()) using (CustomLineCap customLineCap = new CustomLineCap(null, strokePath)) { AssertExtensions.Throws <ArgumentException>(null, () => customLineCap.SetStrokeCaps(startCap, endCap)); // start and end cap should be unchanged. customLineCap.GetStrokeCaps(out LineCap retrievedStartCap, out LineCap retrievedEndCap); Assert.Equal(LineCap.Flat, retrievedStartCap); Assert.Equal(LineCap.Flat, retrievedEndCap); } }
/// <summary> /// Serialization constructor /// </summary> /// <param name="info"></param> /// <param name="context"></param> public CustomLineCapRef(SerializationInfo info, StreamingContext context) { var baseCap = (LineCap)info.GetInt32("BaseCap"); var baseInset = info.GetSingle("BaseInset"); var fillPath = (GraphicsPath)info.GetValue("FillPath", (typeof(GraphicsPath))); var strokePath = (GraphicsPath)info.GetValue("StrokePath", (typeof(GraphicsPath))); var startCap = (LineCap)info.GetInt32("StartCap"); var endCap = (LineCap)info.GetInt32("StartCap"); _clp = new CustomLineCap(fillPath, strokePath, baseCap, baseInset); _clp.StrokeJoin = (LineJoin)info.GetInt32("StrokeJoin"); _clp.WidthScale = info.GetSingle("WidthScale"); _clp.SetStrokeCaps(startCap, endCap); }
public void Disposed_MembersThrow() { using (GraphicsPath strokePath = new GraphicsPath()) using (CustomLineCap customLineCap = new CustomLineCap(null, strokePath)) { customLineCap.Dispose(); AssertExtensions.Throws <ArgumentException>(null, () => customLineCap.StrokeJoin); AssertExtensions.Throws <ArgumentException>(null, () => customLineCap.BaseCap); AssertExtensions.Throws <ArgumentException>(null, () => customLineCap.BaseInset); AssertExtensions.Throws <ArgumentException>(null, () => customLineCap.WidthScale); AssertExtensions.Throws <ArgumentException>(null, () => customLineCap.Clone()); AssertExtensions.Throws <ArgumentException>(null, () => customLineCap.SetStrokeCaps(LineCap.Flat, LineCap.Flat)); AssertExtensions.Throws <ArgumentException>(null, () => customLineCap.GetStrokeCaps(out LineCap startCap, out LineCap endCap)); } }
private CustomLineCap GetClone(Pen pen, float size) { float endPoint; endPoint = pen.Width == 0 ? 1 : size / pen.Width; var hPath = new GraphicsPath(); // Create the outline for our custom end cap. hPath.AddLine(new PointF(-endPoint / 2, 0), new PointF(endPoint / 2, 0)); var clone = new CustomLineCap(null, hPath); // we set the stroke path only clone.SetStrokeCaps(LineCap.Flat, LineCap.Flat); return(clone); }
private void DrawIncludes(Point start, Point end) { GraphicsPath hPath = new GraphicsPath(); hPath.AddLine(0, 0, -2, -2); hPath.AddLine(0, 0, 2, -2); CustomLineCap HookCap = new CustomLineCap(null, hPath); HookCap.SetStrokeCaps(LineCap.Round, LineCap.Round); HookCap.WidthScale = 1.7f; float[] dashValues = { 2, 2, 2, 2 }; Pen arrowPen = new Pen(this.Pen.Color, this.Pen.Width); arrowPen.DashPattern = dashValues; arrowPen.CustomEndCap = HookCap; this.Graphics.DrawLine(arrowPen, start, end); }
private CustomLineCap ArrowLineCap() { float num = 1f; GraphicsPath graphicsPath = new GraphicsPath(); graphicsPath.AddLines(new PointF[5] { new PointF(0f, 0f), new PointF(-1f * num, 0f), new PointF(0f, 3f * num), new PointF(1f * num, 0f), new PointF(0f, 0f) }); graphicsPath.CloseAllFigures(); CustomLineCap customLineCap = new CustomLineCap(null, graphicsPath, LineCap.ArrowAnchor); customLineCap.SetStrokeCaps(LineCap.Flat, LineCap.Flat); graphicsPath.Dispose(); return(customLineCap); }
static Edge2() { GraphicsPath hPath = new GraphicsPath(); // Create the outline for the custom end cap. float sin = arrowSize * (float)Math.Sin(Math.PI / 3); float cos = arrowSize * 0.5f; hPath.AddPolygon(new PointF[] { new PointF(0, 0), new PointF(cos, -sin), new PointF(-cos, -sin) }); // Construct the hook-shaped end cap. CustomLineCap HookCap = new CustomLineCap(hPath, null); // Set the start cap and end cap of the HookCap to be rounded. HookCap.SetStrokeCaps(LineCap.Round, LineCap.Round); linePen = new Pen(Color.Black, 1f); linePen.StartCap = LineCap.RoundAnchor; linePen.CustomEndCap = HookCap; linePen.LineJoin = LineJoin.Round; }
//////////////////////// protected void DrawCaps(PaintEventArgs e) { GraphicsPath hPath = new GraphicsPath(); // Create the outline for our custom end cap. hPath.AddLine(new Point(0, 0), new Point(0, 5)); hPath.AddLine(new Point(0, 5), new Point(5, 1)); hPath.AddLine(new Point(5, 1), new Point(3, 1)); // Construct the hook-shaped end cap. CustomLineCap HookCap = new CustomLineCap(null, hPath); // Set the start cap and end cap of the HookCap to be rounded. HookCap.SetStrokeCaps(LineCap.Round, LineCap.Round); // Create a pen and set end custom start and end // caps to the hook cap. Pen customCapPen = new Pen(Color.Black, 5); customCapPen.CustomStartCap = HookCap; customCapPen.CustomEndCap = HookCap; // Create a second pen using the start and end caps from // the hook cap. Pen capPen = new Pen(Color.Red, 10); LineCap startCap; LineCap endCap; HookCap.GetStrokeCaps(out startCap, out endCap); capPen.StartCap = startCap; capPen.EndCap = endCap; // Create a line to draw. Point[] points = { new Point(100, 100), new Point(200, 50), new Point(250, 300) }; // Draw the lines. e.Graphics.DrawLines(capPen, points); e.Graphics.DrawLines(customCapPen, points); }
private void SetStrokeCapsMenu_Click(object sender, System.EventArgs e) { // Create a graphic Graphics g = this.CreateGraphics(); g.Clear(this.BackColor); // Create a path for custom line cap. This // path will have two lines from points // -3, -3 to 0, 0 and 0, 0 to 3, -3 Point[] points = { new Point(-3, -3), new Point(0, 0), new Point(3, -3) }; GraphicsPath path = new GraphicsPath(); path.AddLines(points); // Create a Custom line cap from the path CustomLineCap cap = new CustomLineCap(null, path); // Set the start and end caps of the Custom cap cap.SetStrokeCaps(LineCap.Round, LineCap.Triangle); // Create a Pen object and set its start and end // caps Pen redPen = new Pen(Color.Red, 15); redPen.CustomStartCap = cap; redPen.CustomEndCap = cap; redPen.DashStyle = DashStyle.DashDotDot; // Draw the line g.DrawLine(redPen, new Point(100, 100), new Point(400, 100)); // Dispose g.Dispose(); }
public ConnectionDrawer() { penLine.EndCap = LineCap.ArrowAnchor; GraphicsPath hPath = new GraphicsPath(); // Create the outline for our custom end cap. //hPath.AddLine(new Point(1, -8), new Point(0,-4)); //hPath.AddLine(new Point(0,-4), new Point(-1,-8)); //hPath.AddLine(new Point(-1,-8), new Point(1,-8)); int bias = 14; int halfWidth = 2; int length = 4; hPath.AddLine(new Point(halfWidth, -bias), new Point(0, -bias + length)); hPath.AddLine(new Point(0, -bias + length), new Point(-halfWidth, -bias)); hPath.AddLine(new Point(-halfWidth, -bias), new Point(halfWidth, -bias)); //hPath.AddLine(new Point(0, 0), new Point(0, 10)); // Construct the hook-shaped end cap. HookCap = new CustomLineCap(null, hPath); // Set the start cap and end cap of the HookCap to be rounded. HookCap.SetStrokeCaps(LineCap.Round, LineCap.Round); penLine.CustomEndCap = HookCap; LineWidth = 1; }
/// <summary> /// Creates a custom line cap given the <paramref name="lineShape"/> and scales. /// </summary> /// <param name="lineShape">Desired line shape.</param> /// <param name="scaleFill">Scale value used for drawing elements that are filled.</param> /// <param name="scaleStroke">Scale value used for drawing elements that are just outlines.</param> /// <returns> /// New <see cref="CustomLineCap"/> configured to produce <paramref name="lineShape"/>. /// </returns> private static CustomLineCap GetLineShapeCap(LineShape lineShape, float scaleFill, float scaleStroke) { float baseInset = 0.0f; bool fill = true; using (var path = new GraphicsPath()) { switch (lineShape) { case LineShape.Arrow: { var size = new SizeF(2.75f * scaleStroke, 4.0f * scaleStroke); var halfW = size.Width * 0.5f; var height = size.Height; fill = false; path.AddLines(new PointF[] { new PointF(-halfW, -height), new PointF(0, 0), new PointF(halfW, -height) }); } break; case LineShape.SolidArrow: { var size = new SizeF(4.25f * scaleFill, 5.57f * scaleFill); var halfW = size.Width * 0.5f; var height75 = size.Height * 0.73f; var height25 = size.Height * 0.27f; baseInset = height75; path.AddLines(new PointF[] { new PointF(0, -height75), new PointF(halfW, -height75), new PointF(0, height25), new PointF(-halfW, -height75), new PointF(0, -height75), }); } break; case LineShape.Tail: { var size = new SizeF(2.10f * scaleStroke, 4.0f * scaleStroke); var halfW = size.Width * 0.5f; var height = size.Height; fill = false; path.AddLines(new[] { new PointF(-halfW, 0), new PointF(0, -height * 0.5f), new PointF(halfW, 0) }); path.StartFigure(); path.AddLines(new[] { new PointF(-halfW, height * 0.5f), new PointF(0, 0), new PointF(halfW, height * 0.5f) }); } break; case LineShape.SolidTail: { var size = new SizeF(3.02f * scaleFill, 4.65f * scaleFill); var halfW = size.Width * 0.5f; var halfH = size.Height * 0.5f; var height38 = size.Height * 0.38f; var height62 = size.Height * 0.62f; path.AddPolygon(new[] { new PointF(0, -height38), new PointF(halfW, 0), new PointF(halfW, height62), new PointF(0, height62 - height38), new PointF(-halfW, height62), new PointF(-halfW, 0), new PointF(0, -height38), }); } break; case LineShape.Circle: { var size = new SizeF(2.4f * scaleFill, 2.4f * scaleFill); path.AddEllipse(-size.Width * 0.5f, -size.Height * 0.5f, size.Width, size.Height); } break; case LineShape.Square: { var size = new SizeF(3.0f * scaleFill, 3.0f * scaleFill); path.AddRectangle(new RectangleF(-size.Width * 0.5f, -size.Height * 0.5f, size.Width, size.Height)); } break; default: break; } var result = new CustomLineCap(fill ? path : null, fill ? null : path, LineCap.Flat, baseInset); result.SetStrokeCaps(LineCap.Round, LineCap.Round); result.StrokeJoin = LineJoin.Round; return(result); } }