public static GraphicsPath CreateRoundRect(float x, float y, float width, float height, float radius) { GraphicsPath gp = new GraphicsPath(); gp.AddLine(x + radius, y, x + width - (radius * 2), y); gp.AddArc(x + width - (radius * 2), y, radius * 2, radius * 2, 270, 90); gp.AddLine(x + width, y + radius, x + width, y + height - (radius * 2)); gp.AddArc(x + width - (radius * 2), y + height - (radius * 2), radius * 2, radius * 2, 0, 90); gp.AddLine(x + width - (radius * 2), y + height, x + radius, y + height); gp.AddArc(x, y + height - (radius * 2), radius * 2, radius * 2, 90, 90); gp.AddLine(x, y + height - (radius * 2), x, y + radius); gp.AddArc(x, y, radius * 2, radius * 2, 180, 90); gp.CloseFigure(); return gp; }
public static GraphicsPath RoundRect(Rectangle rect, int Curve) { GraphicsPath P = new GraphicsPath(); int ArcRectWidth = Curve * 2; P.AddArc(new Rectangle(rect.X, rect.Y, ArcRectWidth, ArcRectWidth), -180, 90); P.AddArc(new Rectangle(rect.Width - ArcRectWidth + rect.X, rect.Y, ArcRectWidth, ArcRectWidth), -90, 90); P.AddArc(new Rectangle(rect.Width - ArcRectWidth + rect.X, rect.Height - ArcRectWidth + rect.Y, ArcRectWidth, ArcRectWidth), 0, 90); P.AddArc(new Rectangle(rect.X, rect.Height - ArcRectWidth + rect.Y, ArcRectWidth, ArcRectWidth), 90, 90); P.AddLine(new Point(rect.X, rect.Height - ArcRectWidth + rect.Y), new Point(rect.X, Curve + rect.Y)); return P; }
private void DrawBar(Graphics objGraphics, int Value, int BarNumber, string Label) { int intLeft = (BarNumber*75)+60; int intBottom = 275; int intHeight = (25*Value); //绘制柱面 objGraphics.FillRectangle(Brushes.Red,intLeft, intBottom-intHeight,35,intHeight); //使用GraphicsPath方法绘制柱面顶层 GraphicsPath pthTop = new GraphicsPath(); pthTop.AddLine(intLeft-1, intBottom-intHeight, intLeft+20, intBottom-intHeight-10); pthTop.AddLine(intLeft+55,intBottom- intHeight-10,intLeft+35, intBottom-intHeight); objGraphics.FillPath(Brushes.LightSalmon, pthTop); // 绘制柱面左侧 GraphicsPath pthRight = new GraphicsPath(); pthRight.AddLine(intLeft+35,intBottom- intHeight,intLeft+55,intBottom- intHeight-10); pthRight.AddLine(intLeft+55, intBottom-15,intLeft+35,intBottom); objGraphics.FillPath(Brushes.Firebrick, pthRight); //绘制标签 objGraphics.TranslateTransform(intLeft+15, intBottom-intHeight - 30); objGraphics.RotateTransform(300); objGraphics.DrawString(Label,new Font("Arial",10,FontStyle.Bold), Brushes.Black,0,0); objGraphics.ResetTransform(); }
public override void Paint(Graphics g) { base.Paint(g); if (mCollapsed) { Rectangle = new RectangleF(Rectangle.X, Rectangle.Y, 200, 50); } else { Rectangle = new RectangleF(Rectangle.X, Rectangle.Y, 200, 100); } DashStyle estiloAnterior = Pen.DashStyle; float anchoAnterior = Pen.Width; Color colorAnterior = Pen.Color; if (this.IsSelected) { Pen.DashStyle = DashStyle.Solid; Pen.Color = Color.Orange; Pen.Width = 2; } else { Pen.DashStyle = DashStyle.Dash; } GraphicsPath path = new GraphicsPath(); path.AddArc(Rectangle.X, Rectangle.Y, 20, 20, -180, 90); path.AddLine(Rectangle.X + 10, Rectangle.Y, Rectangle.X + Rectangle.Width - 10, Rectangle.Y); path.AddArc(Rectangle.X + Rectangle.Width - 20, Rectangle.Y, 20, 20, -90, 90); path.AddLine(Rectangle.X + Rectangle.Width, Rectangle.Y + 10, Rectangle.X + Rectangle.Width, Rectangle.Y + Rectangle.Height - 10); path.AddArc(Rectangle.X + Rectangle.Width - 20, Rectangle.Y + Rectangle.Height - 20, 20, 20, 0, 90); path.AddLine(Rectangle.X + Rectangle.Width - 10, Rectangle.Y + Rectangle.Height, Rectangle.X + 10, Rectangle.Y + Rectangle.Height); path.AddArc(Rectangle.X, Rectangle.Y + Rectangle.Height - 20, 20, 20, 90, 90); path.AddLine(Rectangle.X, Rectangle.Y + Rectangle.Height - 10, Rectangle.X, Rectangle.Y + 10); //shadow Region darkRegion = new Region(path); darkRegion.Translate(5, 5); g.FillRegion(new SolidBrush(Color.FromArgb(20, Color.Black)), darkRegion); //background g.FillPath(new SolidBrush(Color.White), path); if (mCollapsed) { //Pinto el gradiente Brush unBrush = new LinearGradientBrush(new Point(((int)(Rectangle.X)), ((int)(Rectangle.Y))), new Point(((int)(Rectangle.X + Rectangle.Width)), ((int)(Rectangle.Y))), ShapeColor, Color.White); Region unaRegion = new Region(path); g.FillRegion(unBrush, unaRegion); } else { GraphicsPath gradientPath = new GraphicsPath(); gradientPath.AddArc(Rectangle.X + 1, Rectangle.Y + 1, 18, 18, -180, 90); gradientPath.AddLine(Rectangle.X + 11, Rectangle.Y + 1, Rectangle.X + Rectangle.Width - 11, Rectangle.Y + 1); gradientPath.AddArc(Rectangle.X + Rectangle.Width - 19, Rectangle.Y + 1, 18, 18, -90, 90); gradientPath.AddLine(Rectangle.X + Rectangle.Width - 1, Rectangle.Y + 50, Rectangle.X + 1, Rectangle.Y + 50); //gradient Brush unBrush = new LinearGradientBrush(new Point(((int)(Rectangle.X)), ((int)(Rectangle.Y))), new Point(((int)(Rectangle.X + Rectangle.Width)), ((int)(Rectangle.Y))), ShapeColor, Color.White); Region unaRegion = new Region(gradientPath); g.FillRegion(unBrush, unaRegion); } //the border g.DrawPath(Pen, path); Pen.DashStyle = estiloAnterior; Pen.Width = anchoAnterior; Pen.Color = colorAnterior; switch (mSubType) { case SubTypes.Task: g.DrawImage(new Bitmap(this.GetType(), "Resources.task.ico"), ((int)(Rectangle.X + 5)), ((int)(Rectangle.Y + 5))); break; case SubTypes.Event: g.DrawImage(new Bitmap(this.GetType(), "Resources.event.ico"), ((int)(Rectangle.X + 5)), ((int)(Rectangle.Y + 5))); break; } StringFormat sf = new StringFormat(); sf.Trimming = StringTrimming.EllipsisCharacter; g.DrawString(mTitle, new Font("Verdana", 10, FontStyle.Bold), TextBrush, Rectangle.X + 20, Rectangle.Y + 5); g.DrawString(mSubtitle, new Font("Verdana", 8), TextBrush, new RectangleF(Rectangle.X + 5, Rectangle.Y + 22, Rectangle.Width - 10, 28), sf); if (mCollapsed) { g.DrawImage(new Bitmap(this.GetType(), "Resources.down.ico"), ((int)(Rectangle.Right - 20)), ((int)(Rectangle.Y + 5))); } else { g.DrawImage(new Bitmap(this.GetType(), "Resources.up.ico"), ((int)(Rectangle.Right - 20)), ((int)(Rectangle.Y + 5))); g.DrawString(mObservation, new Font("Verdana", 8), TextBrush, new RectangleF(Rectangle.X + 5, Rectangle.Y + 55, Rectangle.Width - 10, 40), sf); } }
/// <summary> /// Makes a border path for rounded borders.<br/> /// To support rounded dotted/dashed borders we need to use arc in the border path.<br/> /// Return null if the border is not rounded.<br/> /// </summary> /// <param name="border">Desired border</param> /// <param name="b">Box which the border corresponds</param> /// <param name="r">the rectangle the border is enclosing</param> /// <returns>Beveled border path, null if there is no rounded corners</returns> static GraphicsPath GetRoundedBorderPath(PaintVisitor p, CssSide border, CssBox b, RectangleF r) { GraphicsPath path = null; switch (border) { case CssSide.Top: if (b.ActualCornerNW > 0 || b.ActualCornerNE > 0) { path = p.GraphicsPlatform.CreateGraphicsPath(); if (b.ActualCornerNW > 0) { path.AddArc(r.Left + b.ActualBorderLeftWidth / 2, r.Top + b.ActualBorderTopWidth / 2, b.ActualCornerNW * 2, b.ActualCornerNW * 2, 180f, 90f); } else { path.AddLine(r.Left + b.ActualBorderLeftWidth / 2, r.Top + b.ActualBorderTopWidth / 2, r.Left + b.ActualBorderLeftWidth, r.Top + b.ActualBorderTopWidth / 2); } if (b.ActualCornerNE > 0) { path.AddArc(r.Right - b.ActualCornerNE * 2 - b.ActualBorderRightWidth / 2, r.Top + b.ActualBorderTopWidth / 2, b.ActualCornerNE * 2, b.ActualCornerNE * 2, 270f, 90f); } else { path.AddLine(r.Right - b.ActualCornerNE * 2 - b.ActualBorderRightWidth, r.Top + b.ActualBorderTopWidth / 2, r.Right - b.ActualBorderRightWidth / 2, r.Top + b.ActualBorderTopWidth / 2); } } break; case CssSide.Bottom: if (b.ActualCornerSW > 0 || b.ActualCornerSE > 0) { path = p.GraphicsPlatform.CreateGraphicsPath(); if (b.ActualCornerSE > 0) { path.AddArc(r.Right - b.ActualCornerNE * 2 - b.ActualBorderRightWidth / 2, r.Bottom - b.ActualCornerSE * 2 - b.ActualBorderBottomWidth / 2, b.ActualCornerSE * 2, b.ActualCornerSE * 2, 0f, 90f); } else { path.AddLine(r.Right - b.ActualBorderRightWidth / 2, r.Bottom - b.ActualBorderBottomWidth / 2, r.Right - b.ActualBorderRightWidth / 2, r.Bottom - b.ActualBorderBottomWidth / 2 - .1f); } if (b.ActualCornerSW > 0) { path.AddArc(r.Left + b.ActualBorderLeftWidth / 2, r.Bottom - b.ActualCornerSW * 2 - b.ActualBorderBottomWidth / 2, b.ActualCornerSW * 2, b.ActualCornerSW * 2, 90f, 90f); } else { path.AddLine(r.Left + b.ActualBorderLeftWidth / 2 + .1f, r.Bottom - b.ActualBorderBottomWidth / 2, r.Left + b.ActualBorderLeftWidth / 2, r.Bottom - b.ActualBorderBottomWidth / 2); } } break; case CssSide.Right: if (b.ActualCornerNE > 0 || b.ActualCornerSE > 0) { path = p.GraphicsPlatform.CreateGraphicsPath(); if (b.ActualCornerNE > 0 && b.BorderTopStyle >= CssBorderStyle.Visible) { path.AddArc(r.Right - b.ActualCornerNE * 2 - b.ActualBorderRightWidth / 2, r.Top + b.ActualBorderTopWidth / 2, b.ActualCornerNE * 2, b.ActualCornerNE * 2, 270f, 90f); } else { path.AddLine(r.Right - b.ActualBorderRightWidth / 2, r.Top + b.ActualCornerNE + b.ActualBorderTopWidth / 2, r.Right - b.ActualBorderRightWidth / 2, r.Top + b.ActualCornerNE + b.ActualBorderTopWidth / 2 + .1f); } if (b.ActualCornerSE > 0 && b.BorderBottomStyle >= CssBorderStyle.Visible) { path.AddArc(r.Right - b.ActualCornerSE * 2 - b.ActualBorderRightWidth / 2, r.Bottom - b.ActualCornerSE * 2 - b.ActualBorderBottomWidth / 2, b.ActualCornerSE * 2, b.ActualCornerSE * 2, 0f, 90f); } else { path.AddLine(r.Right - b.ActualBorderRightWidth / 2, r.Bottom - b.ActualCornerSE - b.ActualBorderBottomWidth / 2 - .1f, r.Right - b.ActualBorderRightWidth / 2, r.Bottom - b.ActualCornerSE - b.ActualBorderBottomWidth / 2); } } break; case CssSide.Left: if (b.ActualCornerNW > 0 || b.ActualCornerSW > 0) { path = p.GraphicsPlatform.CreateGraphicsPath(); if (b.ActualCornerSW > 0 && b.BorderTopStyle >= CssBorderStyle.Visible) //(b.BorderTopStyle == CssConstants.None || b.BorderTopStyle == CssConstants.Hidden)) { path.AddArc(r.Left + b.ActualBorderLeftWidth / 2, r.Bottom - b.ActualCornerSW * 2 - b.ActualBorderBottomWidth / 2, b.ActualCornerSW * 2, b.ActualCornerSW * 2, 90f, 90f); } else { path.AddLine(r.Left + b.ActualBorderLeftWidth / 2, r.Bottom - b.ActualCornerSW - b.ActualBorderBottomWidth / 2, r.Left + b.ActualBorderLeftWidth / 2, r.Bottom - b.ActualCornerSW - b.ActualBorderBottomWidth / 2 - .1f); } if (b.ActualCornerNW > 0 && b.BorderBottomStyle >= CssBorderStyle.Visible) { path.AddArc(r.Left + b.ActualBorderLeftWidth / 2, r.Top + b.ActualBorderTopWidth / 2, b.ActualCornerNW * 2, b.ActualCornerNW * 2, 180f, 90f); } else { path.AddLine(r.Left + b.ActualBorderLeftWidth / 2, r.Top + b.ActualCornerNW + b.ActualBorderTopWidth / 2 + .1f, r.Left + b.ActualBorderLeftWidth / 2, r.Top + b.ActualCornerNW + b.ActualBorderTopWidth / 2); } } break; } return(path); }
public override void AddToPath(GraphicsPath graphicsPath) { if (this.Start == this.End) { return; } if (this.RadiusX == 0.0f && this.RadiusY == 0.0f) { graphicsPath.AddLine(this.Start, this.End); return; } double sinPhi = Math.Sin(this.Angle * SvgArcSegment.RadiansPerDegree); double cosPhi = Math.Cos(this.Angle * SvgArcSegment.RadiansPerDegree); double x1dash = cosPhi * (this.Start.X - this.End.X) / 2.0 + sinPhi * (this.Start.Y - this.End.Y) / 2.0; double y1dash = -sinPhi * (this.Start.X - this.End.X) / 2.0 + cosPhi * (this.Start.Y - this.End.Y) / 2.0; double root; double numerator = this.RadiusX * this.RadiusX * this.RadiusY * this.RadiusY - this.RadiusX * this.RadiusX * y1dash * y1dash - this.RadiusY * this.RadiusY * x1dash * x1dash; float rx = this.RadiusX; float ry = this.RadiusY; if (numerator < 0.0) { float s = (float)Math.Sqrt(1.0 - numerator / (this.RadiusX * this.RadiusX * this.RadiusY * this.RadiusY)); rx *= s; ry *= s; root = 0.0; } else { root = ((this.Size == SvgArcSize.Large && this.Sweep == SvgArcSweep.Positive) || (this.Size == SvgArcSize.Small && this.Sweep == SvgArcSweep.Negative) ? -1.0 : 1.0) * Math.Sqrt(numerator / (this.RadiusX * this.RadiusX * y1dash * y1dash + this.RadiusY * this.RadiusY * x1dash * x1dash)); } double cxdash = root * rx * y1dash / ry; double cydash = -root * ry * x1dash / rx; double cx = cosPhi * cxdash - sinPhi * cydash + (this.Start.X + this.End.X) / 2.0; double cy = sinPhi * cxdash + cosPhi * cydash + (this.Start.Y + this.End.Y) / 2.0; double theta1 = SvgArcSegment.CalculateVectorAngle(1.0, 0.0, (x1dash - cxdash) / rx, (y1dash - cydash) / ry); double dtheta = SvgArcSegment.CalculateVectorAngle((x1dash - cxdash) / rx, (y1dash - cydash) / ry, (-x1dash - cxdash) / rx, (-y1dash - cydash) / ry); if (this.Sweep == SvgArcSweep.Negative && dtheta > 0) { dtheta -= 2.0 * Math.PI; } else if (this.Sweep == SvgArcSweep.Positive && dtheta < 0) { dtheta += 2.0 * Math.PI; } int segments = (int)Math.Ceiling((double)Math.Abs(dtheta / (Math.PI / 2.0))); double delta = dtheta / segments; double t = 8.0 / 3.0 * Math.Sin(delta / 4.0) * Math.Sin(delta / 4.0) / Math.Sin(delta / 2.0); double startX = this.Start.X; double startY = this.Start.Y; for (int i = 0; i < segments; ++i) { double cosTheta1 = Math.Cos(theta1); double sinTheta1 = Math.Sin(theta1); double theta2 = theta1 + delta; double cosTheta2 = Math.Cos(theta2); double sinTheta2 = Math.Sin(theta2); double endpointX = cosPhi * rx * cosTheta2 - sinPhi * ry * sinTheta2 + cx; double endpointY = sinPhi * rx * cosTheta2 + cosPhi * ry * sinTheta2 + cy; double dx1 = t * (-cosPhi * rx * sinTheta1 - sinPhi * ry * cosTheta1); double dy1 = t * (-sinPhi * rx * sinTheta1 + cosPhi * ry * cosTheta1); double dxe = t * (cosPhi * rx * sinTheta2 + sinPhi * ry * cosTheta2); double dye = t * (sinPhi * rx * sinTheta2 - cosPhi * ry * cosTheta2); graphicsPath.AddBezier((float)startX, (float)startY, (float)(startX + dx1), (float)(startY + dy1), (float)(endpointX + dxe), (float)(endpointY + dye), (float)endpointX, (float)endpointY); theta1 = theta2; startX = (float)endpointX; startY = (float)endpointY; } }
protected override void OnPaint(PaintEventArgs e) { Graphics g = e.Graphics; Rectangle bounds = this.ClientRectangle; bounds.Offset(1, 1); bounds.Inflate(-2, -2); Color startColor = SystemColors.ControlLightLight; Color endColor = SystemColors.Control; if (selected) { startColor = Mix(SystemColors.ControlLightLight, SystemColors.Highlight, 0.1); endColor = Mix(SystemColors.ControlLightLight, SystemColors.Highlight, 0.65); } Brush gradient = new LinearGradientBrush(bounds, startColor, endColor, LinearGradientMode.ForwardDiagonal); GraphicsPath path = new GraphicsPath(); const int egdeRadius = 3; const int innerMargin = egdeRadius + 2; RectangleF arcRect = new RectangleF(bounds.Location, new SizeF(egdeRadius * 2, egdeRadius * 2)); //top left Arc path.AddArc(arcRect, 180, 90); path.AddLine(bounds.X + egdeRadius, bounds.Y, bounds.Right - egdeRadius, bounds.Y); // top right arc arcRect.X = bounds.Right - egdeRadius * 2; path.AddArc(arcRect, 270, 90); path.AddLine(bounds.Right, bounds.Left + egdeRadius, bounds.Right, bounds.Bottom - egdeRadius); // bottom right arc arcRect.Y = bounds.Bottom - egdeRadius * 2; path.AddArc(arcRect, 0, 90); path.AddLine(bounds.X + egdeRadius, bounds.Bottom, bounds.Right - egdeRadius, bounds.Bottom); // bottom left arc arcRect.X = bounds.Left; path.AddArc(arcRect, 90, 90); path.AddLine(bounds.X, bounds.Left + egdeRadius, bounds.X, bounds.Bottom - egdeRadius); g.FillPath(gradient, path); g.DrawPath(SystemPens.ControlText, path); path.Dispose(); gradient.Dispose(); Brush textBrush; string description = GetText(out textBrush); int titleWidth; using (Font boldFont = new Font("Arial", 8, FontStyle.Bold)) { g.DrawString(addIn.Name, boldFont, textBrush, innerMargin, innerMargin); titleWidth = (int)g.MeasureString(addIn.Name, boldFont).Width + 1; } if (addIn.Version != null && addIn.Version.ToString() != "0.0.0.0") { g.DrawString(addIn.Version.ToString(), Font, textBrush, innerMargin + titleWidth + 4, innerMargin); } RectangleF textBounds = bounds; textBounds.Offset(innerMargin, innerMargin); textBounds.Inflate(-innerMargin * 2, -innerMargin * 2 + 2); if (isExternal) { textBounds.Height -= pathHeight; } using (StringFormat sf = new StringFormat(StringFormatFlags.LineLimit)) { sf.Trimming = StringTrimming.EllipsisWord; g.DrawString(description, Font, textBrush, textBounds, sf); } if (isExternal) { textBounds.Y = textBounds.Bottom + 2; textBounds.Height = pathHeight + 2; using (Font font = new Font(Font.Name, 7, FontStyle.Italic)) { using (StringFormat sf = new StringFormat(StringFormatFlags.NoWrap)) { sf.Trimming = StringTrimming.EllipsisPath; sf.Alignment = StringAlignment.Far; g.DrawString(addIn.FileName, font, selected ? SystemBrushes.HighlightText : SystemBrushes.ControlText, textBounds, sf); } } } }
protected override void OnPaint(PaintEventArgs pevent) { Graphics g = pevent.Graphics; g.SmoothingMode = SmoothingMode.AntiAlias; // Create painting objects Brush b = new SolidBrush(this.ForeColor); // Create Rectangle To Limit brush area. Rectangle rect = new Rectangle(0, 0, 150, 150); LinearGradientBrush linearBrush = new LinearGradientBrush(rect, Color.FromArgb(20, 20, 20), this.ForeColor, 225); path = new GraphicsPath(); innerPath = new GraphicsPath(); switch (Rotation) { case 0: { path.AddArc(0, 0, 270, 270, 180, 90); path.AddArc(120, 0, 30, 30, 270, 90); path.AddLine(150, 0, 150, 85); path.AddArc(100, 100, 100, 100, -90, -90); path.AddLine(100, 150, 0, 150); path.AddArc(0, 120, 30, 30, 90, 90); innerPath.AddArc(10, 10, 250, 250, 180, 90); innerPath.AddArc(130, 10, 10, 10, 270, 90); innerPath.AddLine(140, 0, 140, 90); innerPath.AddArc(90, 90, 100, 100, -90, -90); innerPath.AddLine(90, 140, 10, 140); innerPath.AddArc(10, 130, 10, 10, 90, 90); } break; case 90: { path.AddArc(-120, 0, 270, 270, 270, 90); path.AddArc(120, 120, 30, 30, 0, 90); path.AddLine(135, 150, 50, 150); path.AddArc(-50, 100, 100, 100, 0, -90); path.AddLine(0, 100, 0, 15); path.AddArc(0, 0, 30, 30, 180, 90); innerPath.AddArc(-110, 10, 250, 250, 270, 90); innerPath.AddArc(130, 130, 10, 10, 0, 90); innerPath.AddLine(130, 140, 60, 140); innerPath.AddArc(-40, 90, 100, 100, 0, -90); innerPath.AddLine(10, 90, 10, 10); innerPath.AddArc(10, 10, 10, 10, 180, 90); } break; case 180: { path.AddArc(-120, -120, 270, 270, 0, 90); path.AddArc(0, 120, 30, 30, 90, 90); path.AddLine(0, 135, 0, 50); path.AddArc(-50, -50, 100, 100, 90, -90); path.AddLine(50, 0, 135, 0); path.AddArc(120, 0, 30, 30, 270, 90); innerPath.AddArc(-110, -110, 250, 250, 0, 90); innerPath.AddArc(10, 130, 10, 10, 90, 90); innerPath.AddLine(10, 125, 10, 60); innerPath.AddArc(-40, -40, 100, 100, 90, -90); innerPath.AddLine(60, 10, 135, 10); innerPath.AddArc(130, 10, 10, 10, 270, 90); } break; case 270: { path.AddArc(0, -120, 270, 270, 90, 90); path.AddArc(0, 0, 30, 30, 180, 90); path.AddLine(15, 0, 100, 0); path.AddArc(100, -50, 100, 100, 180, -90); path.AddLine(150, 50, 150, 135); path.AddArc(120, 120, 30, 30, 0, 90); innerPath.AddArc(10, -110, 250, 250, 90, 90); innerPath.AddArc(10, 10, 10, 10, 180, 90); innerPath.AddLine(5, 10, 60, 10); innerPath.AddArc(90, -40, 100, 100, 180, -90); innerPath.AddLine(140, 60, 140, 135); innerPath.AddArc(130, 130, 10, 10, 0, 90); } break; } this.Region = new Region(path); PathGradientBrush pgbrush = new PathGradientBrush(innerPath); pgbrush.CenterPoint = new Point(75, 75); pgbrush.CenterColor = Color.White; pgbrush.SurroundColors = new Color[] { Color.FromArgb(250, this.ForeColor) }; if (_clicked == false) { g.FillPath(linearBrush, path); g.FillPath(b, innerPath); } else { g.FillPath(linearBrush, path); g.FillPath(pgbrush, innerPath); } // Dispose of painting objects b.Dispose(); pgbrush.Dispose(); linearBrush.Dispose(); }
private void DrawClose(int x, int y) { if (ClosePath == null) { ClosePath = new GraphicsPath(); ClosePath.AddLine(x + 1, y, x + 3, y); ClosePath.AddLine(x + 5, y + 2, x + 7, y); ClosePath.AddLine(x + 9, y, x + 10, y + 1); ClosePath.AddLine(x + 7, y + 4, x + 7, y + 5); ClosePath.AddLine(x + 10, y + 8, x + 9, y + 9); ClosePath.AddLine(x + 7, y + 9, x + 5, y + 7); ClosePath.AddLine(x + 3, y + 9, x + 1, y + 9); ClosePath.AddLine(x + 0, y + 8, x + 3, y + 5); ClosePath.AddLine(x + 3, y + 4, x + 0, y + 1); } G.FillPath(Brushes.White, ClosePath); G.DrawPath(Pens.Black, ClosePath); }
private GraphicsPath CreateCloseFlagPath(Rectangle rect) { var tf = new PointF(rect.X + (rect.Width / 2f), rect.Y + (rect.Height / 2f)); var path = new GraphicsPath(); path.AddLine(tf.X, tf.Y - 2f, tf.X - 2f, tf.Y - 4f); path.AddLine(tf.X - 2f, tf.Y - 4f, tf.X - 6f, tf.Y - 4f); path.AddLine(tf.X - 6f, tf.Y - 4f, tf.X - 2f, tf.Y); path.AddLine(tf.X - 2f, tf.Y, tf.X - 6f, tf.Y + 4f); path.AddLine(tf.X - 6f, tf.Y + 4f, tf.X - 2f, tf.Y + 4f); path.AddLine(tf.X - 2f, tf.Y + 4f, tf.X, tf.Y + 2f); path.AddLine(tf.X, tf.Y + 2f, tf.X + 2f, tf.Y + 4f); path.AddLine(tf.X + 2f, tf.Y + 4f, tf.X + 6f, tf.Y + 4f); path.AddLine(tf.X + 6f, tf.Y + 4f, tf.X + 2f, tf.Y); path.AddLine(tf.X + 2f, tf.Y, tf.X + 6f, tf.Y - 4f); path.AddLine(tf.X + 6f, tf.Y - 4f, tf.X + 2f, tf.Y - 4f); path.CloseFigure(); return(path); }
private GraphicsPath RoundRectangle(Rectangle r, int radius, GroupBoxCorners corners) { GraphicsPath path = new GraphicsPath(); if (r.Width <= 0 | r.Height <= 0) return path; int d = radius * 2; int nw = ((corners & GroupBoxCorners.NorthWest) == GroupBoxCorners.NorthWest ? d : 0); int ne = ((corners & GroupBoxCorners.NorthEast) == GroupBoxCorners.NorthEast ? d : 0); int se = ((corners & GroupBoxCorners.SouthEast) == GroupBoxCorners.SouthEast ? d : 0); int sw = ((corners & GroupBoxCorners.SouthWest) == GroupBoxCorners.SouthWest ? d : 0); path.AddLine(r.Left + nw, r.Top, r.Right - ne, r.Top); if (ne > 0) { path.AddArc(Rectangle.FromLTRB(r.Right - ne, r.Top, r.Right, r.Top + ne), -90, 90); } path.AddLine(r.Right, r.Top + ne, r.Right, r.Bottom - se); if (se > 0) { path.AddArc(Rectangle.FromLTRB(r.Right - se, r.Bottom - se, r.Right, r.Bottom), 0, 90); } path.AddLine(r.Right - se, r.Bottom, r.Left + sw, r.Bottom); if (sw > 0) { path.AddArc(Rectangle.FromLTRB(r.Left, r.Bottom - sw, r.Left + sw, r.Bottom), 90, 90); } path.AddLine(r.Left, r.Bottom - sw, r.Left, r.Top + nw); if (nw > 0) { path.AddArc(Rectangle.FromLTRB(r.Left, r.Top, r.Left + nw, r.Top + nw), 180, 90); } path.CloseFigure(); return path; }
private static Image MakeRoundedCorners(Image image, int radius) { Bitmap bmp = new Bitmap(image, image.Width, image.Height); using (Graphics g = Graphics.FromImage(bmp)) { Brush brush = new SolidBrush(Color.White); for (int i = 0; i < 4; i++) { Point[] cornerUpLeft = new Point[3]; cornerUpLeft[0].X = 0; cornerUpLeft[0].Y = 0; cornerUpLeft[1].X = radius; cornerUpLeft[1].Y = 0; cornerUpLeft[2].X = 0; cornerUpLeft[2].Y = radius; GraphicsPath pathCornerUpLeft = new GraphicsPath(); pathCornerUpLeft.AddArc(cornerUpLeft[0].X, cornerUpLeft[0].Y, radius, radius, 180, 90); pathCornerUpLeft.AddLine(cornerUpLeft[0].X, cornerUpLeft[0].Y, cornerUpLeft[1].X, cornerUpLeft[1].Y); pathCornerUpLeft.AddLine(cornerUpLeft[0].X, cornerUpLeft[0].Y, cornerUpLeft[2].X, cornerUpLeft[2].Y); g.FillPath(brush, pathCornerUpLeft); pathCornerUpLeft.Dispose(); bmp.RotateFlip(RotateFlipType.Rotate90FlipNone); } brush.Dispose(); g.Dispose(); } return bmp; }
public GraphicsPath RoundRect(Rectangle Rectangle, int Curve) { GraphicsPath P = new GraphicsPath(); int ArcRectangleWidth = Curve * 2; P.AddArc(new Rectangle(Rectangle.X, Rectangle.Y, ArcRectangleWidth, ArcRectangleWidth), -180, 90); P.AddArc(new Rectangle(Rectangle.Width - ArcRectangleWidth + Rectangle.X, Rectangle.Y, ArcRectangleWidth, ArcRectangleWidth), -90, 90); P.AddArc(new Rectangle(Rectangle.Width - ArcRectangleWidth + Rectangle.X, Rectangle.Height - ArcRectangleWidth + Rectangle.Y, ArcRectangleWidth, ArcRectangleWidth), 0, 90); P.AddArc(new Rectangle(Rectangle.X, Rectangle.Height - ArcRectangleWidth + Rectangle.Y, ArcRectangleWidth, ArcRectangleWidth), 90, 90); P.AddLine(new Point(Rectangle.X, Rectangle.Height - ArcRectangleWidth + Rectangle.Y), new Point(Rectangle.X, Curve + Rectangle.Y)); return P; }
private static void DrawBorders(Graphics graphics, XPanderPanel xpanderPanel) { if (xpanderPanel.ShowBorder == true) { using (GraphicsPath graphicsPath = new GraphicsPath()) { using (Pen borderPen = new Pen(xpanderPanel.PanelColors.BorderColor, Constants.BorderThickness)) { Rectangle captionRectangle = xpanderPanel.CaptionRectangle; Rectangle borderRectangle = captionRectangle; if (xpanderPanel.Expand == true) { borderRectangle = xpanderPanel.ClientRectangle; graphics.DrawLine( borderPen, captionRectangle.Left, captionRectangle.Top + captionRectangle.Height - Constants.BorderThickness, captionRectangle.Left + captionRectangle.Width, captionRectangle.Top + captionRectangle.Height - Constants.BorderThickness); } XPanderPanelList xpanderPanelList = xpanderPanel.Parent as XPanderPanelList; if ((xpanderPanelList != null) && (xpanderPanelList.Dock == DockStyle.Fill)) { BSE.Windows.Forms.Panel panel = xpanderPanelList.Parent as BSE.Windows.Forms.Panel; XPanderPanel parentXPanderPanel = xpanderPanelList.Parent as XPanderPanel; if (((panel != null) && (panel.Padding == new Padding(0))) || ((parentXPanderPanel != null) && (parentXPanderPanel.Padding == new Padding(0)))) { if (xpanderPanel.Top != 0) { graphicsPath.AddLine( borderRectangle.Left, borderRectangle.Top, borderRectangle.Left + captionRectangle.Width, borderRectangle.Top); } // Left vertical borderline graphics.DrawLine(borderPen, borderRectangle.Left, borderRectangle.Top, borderRectangle.Left, borderRectangle.Top + borderRectangle.Height); // Right vertical borderline graphics.DrawLine(borderPen, borderRectangle.Left + borderRectangle.Width - Constants.BorderThickness, borderRectangle.Top, borderRectangle.Left + borderRectangle.Width - Constants.BorderThickness, borderRectangle.Top + borderRectangle.Height); } else { // Upper horizontal borderline only at the top xpanderPanel if (xpanderPanel.Top == 0) { graphicsPath.AddLine( borderRectangle.Left, borderRectangle.Top, borderRectangle.Left + borderRectangle.Width, borderRectangle.Top); } // Left vertical borderline graphicsPath.AddLine( borderRectangle.Left, borderRectangle.Top, borderRectangle.Left, borderRectangle.Top + borderRectangle.Height); //Lower horizontal borderline graphicsPath.AddLine( borderRectangle.Left, borderRectangle.Top + borderRectangle.Height - Constants.BorderThickness, borderRectangle.Left + borderRectangle.Width - Constants.BorderThickness, borderRectangle.Top + borderRectangle.Height - Constants.BorderThickness); // Right vertical borderline graphicsPath.AddLine( borderRectangle.Left + borderRectangle.Width - Constants.BorderThickness, borderRectangle.Top, borderRectangle.Left + borderRectangle.Width - Constants.BorderThickness, borderRectangle.Top + borderRectangle.Height); } } else { // Upper horizontal borderline only at the top xpanderPanel if (xpanderPanel.Top == 0) { graphicsPath.AddLine( borderRectangle.Left, borderRectangle.Top, borderRectangle.Left + borderRectangle.Width, borderRectangle.Top); } // Left vertical borderline graphicsPath.AddLine( borderRectangle.Left, borderRectangle.Top, borderRectangle.Left, borderRectangle.Top + borderRectangle.Height); //Lower horizontal borderline graphicsPath.AddLine( borderRectangle.Left, borderRectangle.Top + borderRectangle.Height - Constants.BorderThickness, borderRectangle.Left + borderRectangle.Width - Constants.BorderThickness, borderRectangle.Top + borderRectangle.Height - Constants.BorderThickness); // Right vertical borderline graphicsPath.AddLine( borderRectangle.Left + borderRectangle.Width - Constants.BorderThickness, borderRectangle.Top, borderRectangle.Left + borderRectangle.Width - Constants.BorderThickness, borderRectangle.Top + borderRectangle.Height); } } using (Pen borderPen = new Pen(xpanderPanel.PanelColors.BorderColor, Constants.BorderThickness)) { graphics.DrawPath(borderPen, graphicsPath); } } } }
public static GraphicsPath RoundRect(Rectangle Rect, int Rounding, RoundingStyle Style = RoundingStyle.All) { GraphicsPath GP = new GraphicsPath(); int AW = Rounding * 2; GP.StartFigure(); if (Rounding == 0) { GP.AddRectangle(Rect); GP.CloseAllFigures(); return GP; } switch (Style) { case RoundingStyle.All: GP.AddArc(new Rectangle(Rect.X, Rect.Y, AW, AW), -180, 90); GP.AddArc(new Rectangle(Rect.Width - AW + Rect.X, Rect.Y, AW, AW), -90, 90); GP.AddArc(new Rectangle(Rect.Width - AW + Rect.X, Rect.Height - AW + Rect.Y, AW, AW), 0, 90); GP.AddArc(new Rectangle(Rect.X, Rect.Height - AW + Rect.Y, AW, AW), 90, 90); break; case RoundingStyle.Top: GP.AddArc(new Rectangle(Rect.X, Rect.Y, AW, AW), -180, 90); GP.AddArc(new Rectangle(Rect.Width - AW + Rect.X, Rect.Y, AW, AW), -90, 90); GP.AddLine(new Point(Rect.X + Rect.Width, Rect.Y + Rect.Height), new Point(Rect.X, Rect.Y + Rect.Height)); break; case RoundingStyle.Bottom: GP.AddLine(new Point(Rect.X, Rect.Y), new Point(Rect.X + Rect.Width, Rect.Y)); GP.AddArc(new Rectangle(Rect.Width - AW + Rect.X, Rect.Height - AW + Rect.Y, AW, AW), 0, 90); GP.AddArc(new Rectangle(Rect.X, Rect.Height - AW + Rect.Y, AW, AW), 90, 90); break; case RoundingStyle.Left: GP.AddArc(new Rectangle(Rect.X, Rect.Y, AW, AW), -180, 90); GP.AddLine(new Point(Rect.X + Rect.Width, Rect.Y), new Point(Rect.X + Rect.Width, Rect.Y + Rect.Height)); GP.AddArc(new Rectangle(Rect.X, Rect.Height - AW + Rect.Y, AW, AW), 90, 90); break; case RoundingStyle.Right: GP.AddLine(new Point(Rect.X, Rect.Y + Rect.Height), new Point(Rect.X, Rect.Y)); GP.AddArc(new Rectangle(Rect.Width - AW + Rect.X, Rect.Y, AW, AW), -90, 90); GP.AddArc(new Rectangle(Rect.Width - AW + Rect.X, Rect.Height - AW + Rect.Y, AW, AW), 0, 90); break; case RoundingStyle.TopRight: GP.AddLine(new Point(Rect.X, Rect.Y + 1), new Point(Rect.X, Rect.Y)); GP.AddArc(new Rectangle(Rect.Width - AW + Rect.X, Rect.Y, AW, AW), -90, 90); GP.AddLine(new Point(Rect.X + Rect.Width, Rect.Y + Rect.Height - 1), new Point(Rect.X + Rect.Width, Rect.Y + Rect.Height)); GP.AddLine(new Point(Rect.X + 1, Rect.Y + Rect.Height), new Point(Rect.X, Rect.Y + Rect.Height)); break; case RoundingStyle.BottomRight: GP.AddLine(new Point(Rect.X, Rect.Y + 1), new Point(Rect.X, Rect.Y)); GP.AddLine(new Point(Rect.X + Rect.Width - 1, Rect.Y), new Point(Rect.X + Rect.Width, Rect.Y)); GP.AddArc(new Rectangle(Rect.Width - AW + Rect.X, Rect.Height - AW + Rect.Y, AW, AW), 0, 90); GP.AddLine(new Point(Rect.X + 1, Rect.Y + Rect.Height), new Point(Rect.X, Rect.Y + Rect.Height)); break; } GP.CloseAllFigures(); return GP; }
/// <summary> /// Creates the round rect path. /// </summary> /// <param name="rect">The rectangle on which graphics path will be spanned.</param> /// <param name="size">The size of rounded rectangle edges.</param> /// <returns></returns> public static GraphicsPath CreateRoundRectPath(Rectangle rect, Size size) { GraphicsPath gp = new GraphicsPath(); gp.AddLine(rect.Left + size.Width / 2, rect.Top, rect.Right - size.Width / 2, rect.Top); gp.AddArc(rect.Right - size.Width, rect.Top, size.Width, size.Height, 270, 90); gp.AddLine(rect.Right, rect.Top + size.Height / 2, rect.Right, rect.Bottom - size.Width / 2); gp.AddArc(rect.Right - size.Width, rect.Bottom - size.Height, size.Width, size.Height, 0, 90); gp.AddLine(rect.Right - size.Width / 2, rect.Bottom, rect.Left + size.Width / 2, rect.Bottom); gp.AddArc(rect.Left, rect.Bottom - size.Height, size.Width, size.Height, 90, 90); gp.AddLine(rect.Left, rect.Bottom - size.Height / 2, rect.Left, rect.Top + size.Height / 2); gp.AddArc(rect.Left, rect.Top, size.Width, size.Height, 180, 90); return gp; }
protected override void OnPaint(PaintEventArgs e) { base.OnPaint(e); if (IndicatorSizeValue > 0) { Region ControlRegion = null; using (GraphicsPath Path = new GraphicsPath()) { Rectangle OffsetRectangle = new Rectangle(0, 0, this.ClientSize.Width, this.ClientSize.Height); int IndicatorSizeValue2 = (IndicatorSizeValue * 2); int IndicatorStart = 0; if ((IndicatorAlignmentValue == TabAlignment.Left) || (IndicatorAlignmentValue == TabAlignment.Right)) { IndicatorStart = this.Height; } else { IndicatorStart = this.Width; } IndicatorStart -= IndicatorSizeValue2; IndicatorStart = ((IndicatorStart * IndicatorLocationValue) / 100); Path.FillMode = FillMode.Winding; Path.StartFigure(); int IndicatorMiddle = (IndicatorStart + IndicatorSizeValue); int IndicatorEnd = (IndicatorStart + IndicatorSizeValue2); if (IndicatorAlignmentValue == TabAlignment.Left) { OffsetRectangle.X += IndicatorSizeValue; OffsetRectangle.Width -= IndicatorSizeValue; Path.AddLine(OffsetRectangle.Left, IndicatorStart, OffsetRectangle.Left, IndicatorEnd); Path.AddLine(OffsetRectangle.Left, IndicatorEnd, OffsetRectangle.Left - IndicatorSizeValue, IndicatorMiddle); Path.AddLine(OffsetRectangle.Left - IndicatorSizeValue, IndicatorMiddle, OffsetRectangle.Left, IndicatorStart); } else if (IndicatorAlignmentValue == TabAlignment.Right) { OffsetRectangle.Width -= IndicatorSizeValue; Path.AddLine(OffsetRectangle.Right, IndicatorStart, OffsetRectangle.Right + IndicatorSizeValue, IndicatorMiddle); Path.AddLine(OffsetRectangle.Right + IndicatorSizeValue, IndicatorMiddle, OffsetRectangle.Right, IndicatorEnd); Path.AddLine(OffsetRectangle.Right, IndicatorEnd, OffsetRectangle.Right, IndicatorStart); } else if (IndicatorAlignmentValue == TabAlignment.Top) { OffsetRectangle.Y += IndicatorSizeValue; OffsetRectangle.Height -= IndicatorSizeValue; Path.AddLine(IndicatorStart, OffsetRectangle.Top, IndicatorMiddle, OffsetRectangle.Top - IndicatorSizeValue); Path.AddLine(IndicatorMiddle, OffsetRectangle.Top - IndicatorSizeValue, IndicatorEnd, OffsetRectangle.Top); Path.AddLine(IndicatorEnd, OffsetRectangle.Top, IndicatorStart, OffsetRectangle.Top); } else if (IndicatorAlignmentValue == TabAlignment.Bottom) { OffsetRectangle.Height -= IndicatorSizeValue; Path.AddLine(IndicatorStart, OffsetRectangle.Bottom, IndicatorEnd, OffsetRectangle.Bottom); Path.AddLine(IndicatorEnd, OffsetRectangle.Bottom, IndicatorMiddle, OffsetRectangle.Bottom + IndicatorSizeValue); Path.AddLine(IndicatorMiddle, OffsetRectangle.Bottom + IndicatorSizeValue, IndicatorStart, OffsetRectangle.Bottom); } Path.CloseFigure(); Region TabRegion = new Region(Path); ControlRegion = new Region(OffsetRectangle); ControlRegion.Union(TabRegion); } this.Region = ControlRegion; } }
/// <summary> /// Creates <c>GraphicsPath</c> for cylinder surface section. This /// path consists of two arcs and two vertical lines. /// </summary> /// <param name="startAngle"> /// Starting angle of the surface. /// </param> /// <param name="endAngle"> /// Ending angle of the surface. /// </param> /// <param name="pointStart"> /// Starting point on the cylinder surface. /// </param> /// <param name="pointEnd"> /// Ending point on the cylinder surface. /// </param> /// <returns> /// <c>GraphicsPath</c> object representing the cylinder surface. /// </returns> private GraphicsPath CreatePathForCylinderSurfaceSection(float startAngle, float endAngle, GpPointF pointStart, GpPointF pointEnd) { GraphicsPath path = new GraphicsPath(); path.AddArc(m_boundingRectangle.X, m_boundingRectangle.Y, m_boundingRectangle.Width, m_boundingRectangle.Height,startAngle, endAngle - startAngle); path.AddLine(pointEnd.X, pointEnd.Y, pointEnd.X, pointEnd.Y + m_sliceHeight); path.AddArc(m_boundingRectangle.X, m_boundingRectangle.Y + m_sliceHeight, m_boundingRectangle.Width, m_boundingRectangle.Height, endAngle, startAngle - endAngle); path.AddLine(pointStart.X, pointStart.Y + m_sliceHeight, pointStart.X, pointStart.Y); return path; }
private void Draw3DBorder(Graphics g, float offset, Brush color, bool fill, float r, float percent) { int pen_width = 2; float x = this.ClientRectangle.Left + (pen_width / 2) + offset; float y = this.ClientRectangle.Top + (pen_width / 2) + offset; float w = (this.ClientRectangle.Width - (pen_width / 2 + 2 + offset * 2)) * percent; float h = this.ClientRectangle.Height - (pen_width / 2 + 2 + offset * 2); Pen pen = new Pen(color, (float)pen_width); GraphicsPath path = new GraphicsPath(); if (w < 2 * r) { w = 2 * r; } path.AddLine(x + r, y, x + (w - r * 2), y); path.AddArc(x + w - r * 2, y, r * 2, r * 2, 270, 90); path.AddLine(x + w, y + r, x + w, y + h - r * 2); path.AddArc(x + w - r * 2, y + h - r * 2, r * 2, r * 2, 0, 90); path.AddLine(x + w - r * 2, y + h, x + r, y + h); path.AddArc(x, y + h - r * 2, r * 2, r * 2, 90, 90); path.AddLine(x, y + h - r * 2, x, y + r); path.AddArc(x, y, r * 2, r * 2, 180, 90); path.CloseFigure(); g.SmoothingMode = SmoothingMode.AntiAlias; if (fill) { g.FillPath(color, path); } else { g.DrawPath(pen, path); } }
private GraphicsPath CreateBorderPath(Rectangle rect) { GraphicsPath path = new GraphicsPath(); switch (Orientation) { case VisualOrientation.Top: path.AddLine(rect.Left, rect.Bottom - 1, rect.Left, rect.Top + 2); path.AddLine(rect.Left, rect.Top + 2, rect.Left + 2, rect.Top); path.AddLine(rect.Left + 2, rect.Top, rect.Right - 3, rect.Top); path.AddLine(rect.Right - 3, rect.Top, rect.Right - 1, rect.Top + 2); path.AddLine(rect.Right - 1, rect.Top + 2, rect.Right - 1, rect.Bottom - 1); path.AddLine(rect.Right - 1, rect.Bottom - 1, rect.Left, rect.Bottom - 1); break; case VisualOrientation.Bottom: path.AddLine(rect.Left, rect.Top, rect.Left, rect.Bottom - 3); path.AddLine(rect.Left, rect.Bottom - 3, rect.Left + 2, rect.Bottom - 1); path.AddLine(rect.Left + 2, rect.Bottom - 1, rect.Right - 3, rect.Bottom - 1); path.AddLine(rect.Right - 3, rect.Bottom - 1, rect.Right - 1, rect.Bottom - 3); path.AddLine(rect.Right - 1, rect.Bottom - 3, rect.Right - 1, rect.Top); path.AddLine(rect.Right - 1, rect.Top, rect.Left, rect.Top); break; case VisualOrientation.Left: path.AddLine(rect.Right - 1, rect.Top, rect.Left + 2, rect.Top); path.AddLine(rect.Left + 2, rect.Top, rect.Left, rect.Top + 2); path.AddLine(rect.Left, rect.Top + 2, rect.Left, rect.Bottom - 3); path.AddLine(rect.Left, rect.Bottom - 3, rect.Left + 2, rect.Bottom - 1); path.AddLine(rect.Left + 2, rect.Bottom - 1, rect.Right - 1, rect.Bottom - 1); path.AddLine(rect.Right - 1, rect.Bottom - 1, rect.Right - 1, rect.Top); break; case VisualOrientation.Right: path.AddLine(rect.Left, rect.Top, rect.Right - 3, rect.Top); path.AddLine(rect.Right - 3, rect.Top, rect.Right - 1, rect.Top + 2); path.AddLine(rect.Right - 1, rect.Top + 2, rect.Right - 1, rect.Bottom - 3); path.AddLine(rect.Right - 1, rect.Bottom - 3, rect.Right - 3, rect.Bottom - 1); path.AddLine(rect.Right - 3, rect.Bottom - 1, rect.Left, rect.Bottom - 1); path.AddLine(rect.Left, rect.Bottom - 1, rect.Left, rect.Top); break; } return(path); }
internal void ProcessMovement() { // update robot position PointD tOldPosition = m_tPosition; m_tPosition += m_tMovement; m_tMovement = PointD.Empty; // check if we have hit a wall bool bHitWall = false; if (m_tPosition.X - Size.Width / 2.0 < 0) { m_tPosition.X = Size.Width / 2.0; bHitWall = true; } else if (m_tPosition.X + Size.Width / 2.0 > m_pBattle.BattleFieldSize.Width) { m_tPosition.X = m_pBattle.BattleFieldSize.Width - Size.Width / 2.0; bHitWall = true; } if (m_tPosition.Y - Size.Height / 2.0 < 0) { m_tPosition.Y = Size.Height / 2.0; bHitWall = true; } else if (m_tPosition.Y + Size.Height / 2.0 > m_pBattle.BattleFieldSize.Height) { m_tPosition.Y = m_pBattle.BattleFieldSize.Height - Size.Height / 2.0; bHitWall = true; } if (bHitWall) { m_pEvents.Add(new HitWallEvent()); m_dEnergy -= 3.0; } // rotate robot m_nHeading += m_nRotation; if (m_nHeading < 0) { m_nHeading = 360 + m_nHeading; } if (m_nHeading > 359) { m_nHeading -= 360; } m_nRotation = 0; PointF tEndPoint = new PointF((float)(Position.X + Math.Sin(HeadingRadians) * BattleFieldSize.Width), (float)(Position.Y + Math.Cos(HeadingRadians) * BattleFieldSize.Width)); // check if we can see another robot for (int i = 0; i < m_pBattle.Robots.Length; i++) { Robot pRobot = m_pBattle.Robots[i]; // make sure we're not testing against ourselves if (pRobot != this) { GraphicsPath pPath = new GraphicsPath(); pPath.AddLine(Position, tEndPoint); pPath.CloseFigure(); pPath.Widen(new Pen(Color.Black, 1)); Region pRegion = new Region(pPath); pRegion.Intersect(pRobot.Bounds); if (!pRegion.IsEmpty(m_pGraphics)) { // we can see this robot PointD tDistance = pRobot.Position - Position; double dDistance = Math.Sqrt(tDistance.X * tDistance.X + tDistance.Y * tDistance.Y); ScannedRobotEvent pEvent = new ScannedRobotEvent( pRobot.Name, pRobot.Energy, pRobot.Heading - Heading, dDistance, pRobot.Heading, pRobot.Velocity); m_pEvents.Add(pEvent); } } } // check if we have collided with another robot for (int i = 0; i < m_pBattle.Robots.Length; i++) { Robot pRobot = m_pBattle.Robots[i]; // make sure we're not testing against ourselves if (pRobot != this) { if (pRobot.Bounds.IntersectsWith(Bounds)) { // send message to ourselves bool bAtFault = true; HitRobotEvent pEvent = new HitRobotEvent(pRobot.Name, Math.Abs(pRobot.Heading - Heading), pRobot.Energy, bAtFault); m_pEvents.Add(pEvent); m_tPosition = tOldPosition; m_dEnergy -= 3.0; } } } }
public GraphicsPath GetValueRec() { GraphicsPath gp = new GraphicsPath(); gp.AddArc((float)((.05f) * vm.Width), (float)((1f / 3f) * vm.Height), (float)(.90f) * vm.Width, (float)(1.2f) * vm.Height, -180f, 180f); gp.AddLine((float)((.05f) * vm.Width), (float)((70f / 75f) * vm.Height), (float)(.95f) * vm.Width, (float)((70f / 75f) * vm.Height)); return gp; }
/// <summary>Generates the boundary of the hint balloon</summary> private GraphicsPath GeneratePath(bool region_border) { var width = Width + (region_border ? 1 : 0); var height = Height + (region_border ? 1 : 0); var cr = Math.Max(1, CornerRadius); GraphicsPath path; if (TipLength == 0 || TipBaseWidth == 0) { path = Gdi.RoundedRectanglePath(new RectangleF(0, 0, width, height), cr); } else { var tip_length = TipLength; var tip_width = Math_.Clamp(width - 2 * (tip_length + cr), Math.Min(5, TipBaseWidth), TipBaseWidth); // Find the corner to start from path = new GraphicsPath(); switch (TipCorner) { default: Debug.Assert(false, "Unknown corner"); break; case ETipCorner.TopLeft: path.AddLine(0, 0, tip_length + cr + tip_width, tip_length); path.AddArc(width - tip_length - cr, tip_length, cr, cr, 270f, 90f); path.AddArc(width - tip_length - cr, height - tip_length - cr, cr, cr, 0f, 90f); path.AddArc(tip_length, height - tip_length - cr, cr, cr, 90f, 90f); path.AddArc(tip_length, tip_length, cr, cr, 180f, 90f); path.AddLine(tip_length + cr, tip_length, 0, 0); break; case ETipCorner.TopRight: path.AddLine(width, 0, width - tip_length - cr, tip_length); path.AddArc(width - tip_length - cr, tip_length, cr, cr, 270f, 90f); path.AddArc(width - tip_length - cr, height - tip_length - cr, cr, cr, 0f, 90f); path.AddArc(tip_length, height - tip_length - cr, cr, cr, 90f, 90f); path.AddArc(tip_length, tip_length, cr, cr, 180f, 90f); path.AddLine(tip_length + cr, tip_length, width - tip_length - cr - tip_width, tip_length); path.AddLine(width - tip_length - cr - tip_width, tip_length, width, 0); break; case ETipCorner.BottomLeft: path.AddLine(0, height, tip_length + cr, height - tip_length); path.AddArc(tip_length, height - tip_length - cr, cr, cr, 90f, 90f); path.AddArc(tip_length, tip_length, cr, cr, 180f, 90f); path.AddArc(width - tip_length - cr, tip_length, cr, cr, 270f, 90f); path.AddArc(width - tip_length - cr, height - tip_length - cr, cr, cr, 0f, 90f); path.AddLine(width - tip_length - cr, height - tip_length, tip_length + cr + tip_width, height - tip_length); path.AddLine(tip_length + cr + tip_width, height - tip_length, 0, height); break; case ETipCorner.BottomRight: path.AddLine(width, height, width - tip_length - cr - tip_width, height - tip_length); path.AddArc(tip_length, height - tip_length - cr, cr, cr, 90f, 90f); path.AddArc(tip_length, tip_length, cr, cr, 180f, 90f); path.AddArc(width - tip_length - cr, tip_length, cr, cr, 270f, 90f); path.AddArc(width - tip_length - cr, height - tip_length - cr, cr, cr, 0f, 90f); path.AddLine(width - tip_length - cr, height - tip_length, width, height); break; } } return(path); }
public static void DrawDocumentTab(Graphics g, Rectangle rect, Color backColorBegin, Color backColorEnd, Color edgeColor, TabDrawType tabType, bool closed) { GraphicsPath path; Region Region; Brush brush = null; Pen pen; brush = new LinearGradientBrush(rect, backColorBegin, backColorEnd, LinearGradientMode.Vertical); pen = new pen(edgeColor, 1.0F); path = new GraphicsPath(); if (tabType == TabDrawType.First) { path.AddLine(rect.Left + 1, rect.Bottom + 1, rect.Left + rect.Height, rect.Top + 2); path.AddLine(rect.Left + rect.Height + 4, rect.Top, rect.Right - 3, rect.Top); path.AddLine(rect.Right - 1, rect.Top + 2, rect.Right - 1, rect.Bottom + 1); } else { if (tabType == TabDrawType.Active) { path.AddLine(rect.Left + 1, rect.Bottom + 1, rect.Left + rect.Height, rect.Top + 2); path.AddLine(rect.Left + rect.Height + 4, rect.Top, rect.Right - 3, rect.Top); path.AddLine(rect.Right - 1, rect.Top + 2, rect.Right - 1, rect.Bottom + 1); } else { path.AddLine(rect.Left, rect.Top + 6, rect.Left + 4, rect.Top + 2); path.AddLine(rect.Left + 8, rect.Top, rect.Right - 3, rect.Top); path.AddLine(rect.Right - 1, rect.Top + 2, rect.Right - 1, rect.Bottom + 1); path.AddLine(rect.Right - 1, rect.Bottom + 1, rect.Left, rect.Bottom + 1); } } Region = new Region(path); g.FillRegion(brush, Region); g.DrawPath(pen, path); }
public static SharpDX.Direct2D1.Bitmap RedrawMiscNoteBitmapCache(RenderTarget renderTargetSource, Color color) { ImagingFactory factory = new ImagingFactory(); SharpDX.Direct2D1.Factory factory2 = new SharpDX.Direct2D1.Factory(); SharpDX.DirectWrite.Factory factory3 = new SharpDX.DirectWrite.Factory(); SharpDX.WIC.Bitmap wicBitmap = new SharpDX.WIC.Bitmap(factory, 0x10, 0x10, SharpDX.WIC.PixelFormat.Format32bppPBGRA, BitmapCreateCacheOption.CacheOnDemand); RenderTargetProperties renderTargetProperties = new RenderTargetProperties(RenderTargetType.Default, new SharpDX.Direct2D1.PixelFormat(Format.Unknown, SharpDX.Direct2D1.AlphaMode.Unknown), 0f, 0f, RenderTargetUsage.None, FeatureLevel.Level_DEFAULT); WicRenderTarget renderTarget = new WicRenderTarget(factory2, wicBitmap, renderTargetProperties); try { PointF[] pathPoints; renderTarget.BeginDraw(); renderTarget.Clear(new RawColor4?(Color.Transparent.ToRawColor4(1f))); RawVector2 vector = new RawVector2(8f, 8f); using (GraphicsPath path = new GraphicsPath()) { float num = vector.X - 6f; float num2 = vector.Y - 3f; path.AddLine((float)(num + 0f), (float)(num2 + 0f), (float)(num + 12f), (float)(num2 + 0f)); path.AddLine((float)(num + 12f), (float)(num2 + 0f), (float)(num + 12f), (float)(num2 + 6f)); path.AddLine((float)(num + 12f), (float)(num2 + 6f), (float)(num + 0f), (float)(num2 + 6f)); path.AddLine((float)(num + 0f), (float)(num2 + 6f), (float)(num + 0f), (float)(num2 + 0f)); path.Flatten(); pathPoints = path.PathPoints; path.Dispose(); } PathGeometry geometry = new PathGeometry(factory2); if (pathPoints.Length > 1) { GeometrySink sink = geometry.Open(); sink.SetSegmentFlags(PathSegment.ForceRoundLineJoin); sink.BeginFigure(new RawVector2(pathPoints[0].X, pathPoints[0].Y), FigureBegin.Filled); for (int i = 1; i < pathPoints.Length; i++) { sink.AddLine(new RawVector2(pathPoints[i].X, pathPoints[i].Y)); } sink.EndFigure(FigureEnd.Closed); sink.Close(); sink.Dispose(); } SolidColorBrush brush = new SolidColorBrush(renderTarget, color.ToRawColor4(1f)); renderTarget.FillGeometry(geometry, brush); brush.Dispose(); geometry.Dispose(); renderTarget.EndDraw(); } catch (Exception) { factory.Dispose(); factory2.Dispose(); factory3.Dispose(); wicBitmap.Dispose(); renderTarget.Dispose(); return(null); } SharpDX.Direct2D1.Bitmap bitmap2 = SharpDX.Direct2D1.Bitmap.FromWicBitmap(renderTargetSource, wicBitmap); factory.Dispose(); factory2.Dispose(); factory3.Dispose(); wicBitmap.Dispose(); renderTarget.Dispose(); return(bitmap2); }
public void panel1_Paint(object sender, PaintEventArgs e) { Graphics g = e.Graphics; g.SmoothingMode = SmoothingMode.HighQuality; Pen p = new Pen(c.GetPanel1().ForeColor, 3); p.LineJoin = LineJoin.Bevel; string selectedData = "" + c.GetComboBox1().SelectedItem; SizeF stringsize = g.MeasureString(selectedData, c.GetPanel1().Font); g.DrawString(selectedData, c.GetPanel1().Font, p.Brush, new Point(c.GetPanel1().Width - (int)stringsize.Width, 0)); Console.WriteLine(selectedData); switch (c.GetComboBox1().SelectedIndex) { case 0: { g.TranslateTransform(0, c.GetPanel1().Height); Point newPoint = new Point(c.GetPanel1().Width, (int)-(c.getData().heartRate / 1.5 + 5)); PointsHeartrate.Add(newPoint); GraphicsPath path = new GraphicsPath(); path.StartFigure(); for (int i = 0; i < PointsHeartrate.Count; i++) { Point point = PointsHeartrate[i]; point.X -= 4; path.AddLine(oldPoint, point); oldPoint = point; PointsHeartrate[i] = point; } for (int j = PointsHeartrate.Count - 1; j > 0; j--) { Point point = PointsHeartrate[j]; path.AddLine(oldPoint, point); oldPoint = point; PointsHeartrate[j] = point; } g.DrawPath(p, path); for (int k = 0; k < PointsHeartrate.Count; k++) { if (PointsHeartrate[k].X < 0) { PointsHeartrate.RemoveAt(k); } } break; } case 1: { g.TranslateTransform(0, c.GetPanel1().Height); Point newPoint = new Point(c.GetPanel1().Width, (int)-(c.getData().RPM / 1.2 + 5)); this.PointsRPM.Add(newPoint); GraphicsPath path = new GraphicsPath(); path.StartFigure(); for (int i = 0; i < this.PointsRPM.Count; i++) { Point point = this.PointsRPM[i]; point.X -= 4; path.AddLine(oldPoint, point); oldPoint = point; this.PointsRPM[i] = point; } for (int j = this.PointsRPM.Count - 1; j > 0; j--) { Point point = this.PointsRPM[j]; path.AddLine(oldPoint, point); oldPoint = point; this.PointsRPM[j] = point; } g.DrawPath(p, path); for (int k = 0; k < this.PointsRPM.Count; k++) { if (this.PointsRPM[k].X < 0) { this.PointsRPM.RemoveAt(k); } } break; } case 2: { g.TranslateTransform(0, c.GetPanel1().Height); Point newPoint = new Point(c.GetPanel1().Width, (int)-((int)c.getData().speed / (4.2 / 10) + 5)); this.PointsSpeed.Add(newPoint); GraphicsPath path = new GraphicsPath(); path.StartFigure(); for (int i = 0; i < this.PointsSpeed.Count; i++) { Point point = this.PointsSpeed[i]; point.X -= 4; path.AddLine(oldPoint, point); oldPoint = point; this.PointsSpeed[i] = point; } for (int j = this.PointsSpeed.Count - 1; j > 0; j--) { Point point = this.PointsSpeed[j]; path.AddLine(oldPoint, point); oldPoint = point; this.PointsSpeed[j] = point; } g.DrawPath(p, path); for (int k = 0; k < this.PointsSpeed.Count; k++) { if (this.PointsSpeed[k].X < 0) { this.PointsSpeed.RemoveAt(k); } } break; } case 3: { g.TranslateTransform(0, c.GetPanel1().Height); Point newPoint = new Point(c.GetPanel1().Width, (int)-(c.getData().distance / 600 + 5)); this.PointsDistance.Add(newPoint); GraphicsPath path = new GraphicsPath(); path.StartFigure(); for (int i = 0; i < this.PointsDistance.Count; i++) { Point point = this.PointsDistance[i]; point.X -= 4; path.AddLine(oldPoint, point); oldPoint = point; this.PointsDistance[i] = point; } for (int j = this.PointsDistance.Count - 1; j > 0; j--) { Point point = this.PointsDistance[j]; path.AddLine(oldPoint, point); oldPoint = point; this.PointsDistance[j] = point; } g.DrawPath(p, path); for (int k = 0; k < this.PointsDistance.Count; k++) { if (this.PointsDistance[k].X < 0) { this.PointsDistance.RemoveAt(k); } } break; } case 4: { g.TranslateTransform(0, c.GetPanel1().Height); Point newPoint = new Point(c.GetPanel1().Width, (int)-(c.getData().power / 2.4 + 5)); this.PointsPower.Add(newPoint); GraphicsPath path = new GraphicsPath(); path.StartFigure(); for (int i = 0; i < this.PointsPower.Count; i++) { Point point = this.PointsPower[i]; point.X -= 4; path.AddLine(oldPoint, point); oldPoint = point; this.PointsPower[i] = point; } for (int j = this.PointsPower.Count - 1; j > 0; j--) { Point point = this.PointsPower[j]; path.AddLine(oldPoint, point); oldPoint = point; this.PointsPower[j] = point; } g.DrawPath(p, path); for (int k = 0; k < this.PointsPower.Count; k++) { if (this.PointsPower[k].X < 0) { this.PointsPower.RemoveAt(k); } } break; } case 5: { g.TranslateTransform(0, c.GetPanel1().Height); Point newPoint = new Point(c.GetPanel1().Width, (int)-(c.getData().energy / 600 + 5)); this.PointsEnergy.Add(newPoint); GraphicsPath path = new GraphicsPath(); path.StartFigure(); for (int i = 0; i < this.PointsEnergy.Count; i++) { Point point = this.PointsEnergy[i]; point.X -= 4; path.AddLine(oldPoint, point); oldPoint = point; this.PointsEnergy[i] = point; } for (int j = this.PointsEnergy.Count - 1; j > 0; j--) { Point point = this.PointsEnergy[j]; path.AddLine(oldPoint, point); oldPoint = point; this.PointsEnergy[j] = point; } g.DrawPath(p, path); for (int k = 0; k < this.PointsEnergy.Count; k++) { if (this.PointsEnergy[k].X < 0) { this.PointsEnergy.RemoveAt(k); } } break; } case 6: { g.TranslateTransform(0, c.GetPanel1().Height); Point newPoint = new Point(c.GetPanel1().Width, (int)-(c.getData().currentPower / 2.4 + 5)); this.PointsCurrentPower.Add(newPoint); GraphicsPath path = new GraphicsPath(); path.StartFigure(); for (int i = 0; i < this.PointsCurrentPower.Count; i++) { Point point = this.PointsCurrentPower[i]; point.X -= 4; path.AddLine(oldPoint, point); oldPoint = point; this.PointsCurrentPower[i] = point; } for (int j = this.PointsCurrentPower.Count - 1; j > 0; j--) { Point point = this.PointsCurrentPower[j]; path.AddLine(oldPoint, point); oldPoint = point; this.PointsCurrentPower[j] = point; } g.DrawPath(p, path); for (int k = 0; k < this.PointsCurrentPower.Count; k++) { if (this.PointsCurrentPower[k].X < 0) { this.PointsCurrentPower.RemoveAt(k); } } break; } } base.OnPaint(e); g.Dispose(); }
public static SharpDX.Direct2D1.Bitmap RedrawRestNoteBitmapCache(RenderTarget renderTargetSource, Color color, DurationTypes durationType) { ImagingFactory factory = new ImagingFactory(); SharpDX.Direct2D1.Factory factory2 = new SharpDX.Direct2D1.Factory(); SharpDX.DirectWrite.Factory factory3 = new SharpDX.DirectWrite.Factory(); SharpDX.WIC.Bitmap wicBitmap = new SharpDX.WIC.Bitmap(factory, 0x20, 0x30, SharpDX.WIC.PixelFormat.Format32bppPBGRA, BitmapCreateCacheOption.CacheOnDemand); RenderTargetProperties renderTargetProperties = new RenderTargetProperties(RenderTargetType.Default, new SharpDX.Direct2D1.PixelFormat(Format.Unknown, SharpDX.Direct2D1.AlphaMode.Unknown), 0f, 0f, RenderTargetUsage.None, FeatureLevel.Level_DEFAULT); WicRenderTarget renderTarget = new WicRenderTarget(factory2, wicBitmap, renderTargetProperties); try { PointF[] pathPoints; renderTarget.BeginDraw(); renderTarget.Clear(new RawColor4?(Color.Transparent.ToRawColor4(1f))); RawVector2 pos = new RawVector2(18f, 44f); using (GraphicsPath path = new GraphicsPath()) { DurationTypes types = durationType; if (types <= DurationTypes.Eighth) { switch (types) { case DurationTypes.The32nd: pos = new RawVector2(pos.X, (pos.Y - (8f * (((float)McMeasure.StaveSpacing) / 2f))) + 3f); path.AddLine(pos.X, pos.Y, pos.X + 1.6f, pos.Y); path.AddLine(pos.X + 1.6f, pos.Y, (pos.X - 8f) + 2.4f, pos.Y + 41f); path.AddLine((float)((pos.X - 8f) + 2.4f), (float)(pos.Y + 41f), (float)((pos.X - 8f) - 0.8f), (float)(pos.Y + 41f)); path.AddLine((pos.X - 8f) - 0.8f, pos.Y + 41f, pos.X, pos.Y); DrawRestDotPart(renderTarget, pos, color); DrawRestDotPart(renderTarget, new RawVector2(pos.X - 2.2f, pos.Y + 11f), color); DrawRestDotPart(renderTarget, new RawVector2(pos.X - 4.4f, pos.Y + 22f), color); break; case DurationTypes.The16th: pos = new RawVector2(pos.X, (pos.Y - (6f * (((float)McMeasure.StaveSpacing) / 2f))) + 3f); path.AddLine(pos.X, pos.Y, pos.X + 1.6f, pos.Y); path.AddLine(pos.X + 1.6f, pos.Y, (pos.X - 8f) + 2.4f, pos.Y + 30f); path.AddLine((float)((pos.X - 8f) + 2.4f), (float)(pos.Y + 30f), (float)((pos.X - 8f) - 0.8f), (float)(pos.Y + 30f)); path.AddLine((pos.X - 8f) - 0.8f, pos.Y + 30f, pos.X, pos.Y); DrawRestDotPart(renderTarget, pos, color); DrawRestDotPart(renderTarget, new RawVector2(pos.X - 2.4f, pos.Y + 11f), color); break; case DurationTypes.Eighth: goto Label_06F6; } } else { switch (types) { case DurationTypes.Quarter: pos = new RawVector2(pos.X - 11f, pos.Y - (7f * (((float)McMeasure.StaveSpacing) / 2f))); path.AddLine(pos.X, pos.Y, pos.X + 7f, pos.Y + 9.5f); path.AddBezier((float)(pos.X + 7f), (float)(pos.Y + 9.5f), (float)(pos.X + 3f), (float)(pos.Y + 16f), (float)(pos.X + 3f), (float)(pos.Y + 16f), (float)(pos.X + 8f), (float)(pos.Y + 24f)); path.AddBezier((float)(pos.X + 8f), (float)(pos.Y + 24f), (float)(pos.X - 0f), (float)(pos.Y + 21f), (float)(pos.X - 1f), (float)(pos.Y + 26f), (float)(pos.X + 4f), (float)(pos.Y + 34f)); path.AddBezier((float)(pos.X + 4f), (float)(pos.Y + 34f), (float)(pos.X - 8f), (float)(pos.Y + 28f), (float)(pos.X - 4f), (float)(pos.Y + 17f), (float)(pos.X + 4.5f), (float)(pos.Y + 21f)); path.AddLine((float)(pos.X + 4.5f), (float)(pos.Y + 21f), (float)(pos.X - 1f), (float)(pos.Y + 14f)); path.AddBezier((float)(pos.X - 1f), (float)(pos.Y + 14f), (float)(pos.X + 3.5f), (float)(pos.Y + 11f), (float)(pos.X + 4f), (float)(pos.Y + 7f), (float)(pos.X - 1f), (float)(pos.Y + 2f)); goto Label_0AD7; case DurationTypes.Half: pos = new RawVector2(pos.X - 8f, pos.Y - (4f * (((float)McMeasure.StaveSpacing) / 2f))); path.AddLine(pos.X - 7f, pos.Y, pos.X + 7f, pos.Y); path.AddLine(pos.X + 7f, pos.Y, pos.X + 7f, pos.Y - 5f); path.AddLine((float)(pos.X + 7f), (float)(pos.Y - 5f), (float)(pos.X - 7f), (float)(pos.Y - 5f)); path.AddLine(pos.X - 7f, pos.Y - 5f, pos.X - 7f, pos.Y); path.AddLine(pos.X - 7f, pos.Y, pos.X - 10f, pos.Y); path.AddLine(pos.X - 10f, pos.Y, pos.X - 10f, pos.Y + 1f); path.AddLine((float)(pos.X - 10f), (float)(pos.Y + 1f), (float)(pos.X + 10f), (float)(pos.Y + 1f)); path.AddLine(pos.X + 10f, pos.Y + 1f, pos.X + 10f, pos.Y); goto Label_0AD7; } if (types == DurationTypes.Whole) { pos = new RawVector2(pos.X - 8f, pos.Y - (6f * (((float)McMeasure.StaveSpacing) / 2f))); path.AddLine(pos.X - 7f, pos.Y, pos.X + 7f, pos.Y); path.AddLine(pos.X + 7f, pos.Y, pos.X + 7f, pos.Y + 5f); path.AddLine((float)(pos.X + 7f), (float)(pos.Y + 5f), (float)(pos.X - 7f), (float)(pos.Y + 5f)); path.AddLine(pos.X - 7f, pos.Y + 5f, pos.X - 7f, pos.Y); path.AddLine(pos.X - 7f, pos.Y, pos.X - 10f, pos.Y); path.AddLine(pos.X - 10f, pos.Y, pos.X - 10f, pos.Y - 1f); path.AddLine((float)(pos.X - 10f), (float)(pos.Y - 1f), (float)(pos.X + 10f), (float)(pos.Y - 1f)); path.AddLine(pos.X + 10f, pos.Y - 1f, pos.X + 10f, pos.Y); } } goto Label_0AD7; Label_06F6: pos = new RawVector2(pos.X - 2f, (pos.Y - (6f * (((float)McMeasure.StaveSpacing) / 2f))) + 3f); path.AddLine(pos.X, pos.Y, pos.X + 1.6f, pos.Y); path.AddLine(pos.X + 1.6f, pos.Y, (pos.X - 8f) + 2.4f, pos.Y + 19f); path.AddLine((float)((pos.X - 8f) + 2.4f), (float)(pos.Y + 19f), (float)((pos.X - 8f) - 0.8f), (float)(pos.Y + 19f)); path.AddLine((pos.X - 8f) - 0.8f, pos.Y + 19f, pos.X, pos.Y); DrawRestDotPart(renderTarget, pos, color); Label_0AD7: path.Flatten(); pathPoints = path.PathPoints; path.Dispose(); } PathGeometry geometry = new PathGeometry(factory2); if (pathPoints.Length > 1) { GeometrySink sink = geometry.Open(); sink.SetSegmentFlags(PathSegment.ForceRoundLineJoin); sink.BeginFigure(new RawVector2(pathPoints[0].X, pathPoints[0].Y), FigureBegin.Filled); for (int i = 1; i < pathPoints.Length; i++) { sink.AddLine(new RawVector2(pathPoints[i].X, pathPoints[i].Y)); } sink.EndFigure(FigureEnd.Closed); sink.Close(); sink.Dispose(); } SolidColorBrush brush = new SolidColorBrush(renderTarget, color.ToRawColor4(1f)); renderTarget.FillGeometry(geometry, brush); brush.Dispose(); geometry.Dispose(); renderTarget.EndDraw(); } catch (Exception) { factory.Dispose(); factory2.Dispose(); factory3.Dispose(); wicBitmap.Dispose(); renderTarget.Dispose(); return(null); } SharpDX.Direct2D1.Bitmap bitmap2 = SharpDX.Direct2D1.Bitmap.FromWicBitmap(renderTargetSource, wicBitmap); factory.Dispose(); factory2.Dispose(); factory3.Dispose(); wicBitmap.Dispose(); renderTarget.Dispose(); return(bitmap2); }
private GraphicsPath CreateMaximizeFlafPath(Rectangle rect, bool maximize) { var tf = new PointF(rect.X + (rect.Width / 2f), rect.Y + (rect.Height / 2f)); var path = new GraphicsPath(); if (maximize) { path.AddLine(tf.X - 3f, tf.Y - 3f, tf.X - 6f, tf.Y - 3f); path.AddLine(tf.X - 6f, tf.Y - 3f, tf.X - 6f, tf.Y + 5f); path.AddLine(tf.X - 6f, tf.Y + 5f, tf.X + 3f, tf.Y + 5f); path.AddLine(tf.X + 3f, tf.Y + 5f, tf.X + 3f, tf.Y + 1f); path.AddLine(tf.X + 3f, tf.Y + 1f, tf.X + 6f, tf.Y + 1f); path.AddLine(tf.X + 6f, tf.Y + 1f, tf.X + 6f, tf.Y - 6f); path.AddLine(tf.X + 6f, tf.Y - 6f, tf.X - 3f, tf.Y - 6f); path.CloseFigure(); path.AddRectangle(new RectangleF(tf.X - 4f, tf.Y, 5f, 3f)); path.AddLine(tf.X - 1f, tf.Y - 4f, tf.X + 4f, tf.Y - 4f); path.AddLine(tf.X + 4f, tf.Y - 4f, tf.X + 4f, tf.Y - 1f); path.AddLine(tf.X + 4f, tf.Y - 1f, tf.X + 3f, tf.Y - 1f); path.AddLine(tf.X + 3f, tf.Y - 1f, tf.X + 3f, tf.Y - 3f); path.AddLine(tf.X + 3f, tf.Y - 3f, tf.X - 1f, tf.Y - 3f); path.CloseFigure(); return(path); } path.AddRectangle(new RectangleF(tf.X - 6f, tf.Y - 4f, 12f, 8f)); path.AddRectangle(new RectangleF(tf.X - 3f, tf.Y - 1f, 6f, 3f)); return(path); }
public void AddLine(Point pt1, Point pt2) { Changed(); gdiPath.AddLine(pt1, pt2); }
private GraphicsPath CreateTabPath(Rectangle rect) { GraphicsPath path = new GraphicsPath(); switch (Alignment) { case TabAlignment.Top: rect.X++; rect.Width -= 2; path.AddLine( rect.X, rect.Bottom, rect.X, rect.Y + Radius / 2); path.AddArc( rect.X, rect.Y, Radius, Radius, 180F, 90F); path.AddArc( rect.Right - Radius, rect.Y, Radius, Radius, 270F, 90F); path.AddLine( rect.Right, rect.Y + Radius / 2, rect.Right, rect.Bottom); break; case TabAlignment.Bottom: rect.X++; rect.Width -= 2; path.AddLine( rect.X, rect.Y, rect.X, rect.Bottom - Radius / 2); path.AddArc( rect.X, rect.Bottom - Radius, Radius, Radius, 180, -90); path.AddArc( rect.Right - Radius, rect.Bottom - Radius, Radius, Radius, 90, -90); path.AddLine( rect.Right, rect.Bottom - Radius / 2, rect.Right, rect.Y); break; case TabAlignment.Left: rect.Y++; rect.Height -= 2; path.AddLine( rect.Right, rect.Y, rect.X + Radius / 2, rect.Y); path.AddArc( rect.X, rect.Y, Radius, Radius, 270F, -90F); path.AddArc( rect.X, rect.Bottom - Radius, Radius, Radius, 180F, -90F); path.AddLine( rect.X + Radius / 2, rect.Bottom, rect.Right, rect.Bottom); break; case TabAlignment.Right: rect.Y++; rect.Height -= 2; path.AddLine( rect.X, rect.Y, rect.Right - Radius / 2, rect.Y); path.AddArc( rect.Right - Radius, rect.Y, Radius, Radius, 270F, 90F); path.AddArc( rect.Right - Radius, rect.Bottom - Radius, Radius, Radius, 0F, 90F); path.AddLine( rect.Right - Radius / 2, rect.Bottom, rect.X, rect.Bottom); break; } path.CloseFigure(); return(path); }
public GraphicsPath DrawHeart(float Xc, float Yc) { GraphicsPath gp = new GraphicsPath(); Rectangle HeartTopLeftSquare = new Rectangle((int)Xc, (int)Yc, (int)RadiusOuter, (int)RadiusOuter); Rectangle HeartTopRightSquare = new Rectangle((int)Xc + (int)RadiusOuter, (int)Yc, (int)RadiusOuter, (int)RadiusOuter); gp.AddArc(HeartTopLeftSquare, 135f, 225f); gp.AddArc(HeartTopRightSquare, 180f, 225f); gp.AddLine((int)(Xc + (RadiusOuter * 2) - (1 - Math.Sin(45 / 180 * Math.PI)) * RadiusOuter / 2), (int)(Yc + RadiusOuter / 2 + Math.Sin(45 / 180 * Math.PI) * RadiusOuter / 2), (int)(Xc + RadiusOuter), (int)(Yc + (RadiusOuter * 2))); gp.AddLine((int)(Xc + RadiusOuter / 2 - Math.Sin(45 / 180 * Math.PI) * RadiusOuter / 2), (int)(Yc + RadiusOuter / 2 + Math.Sin(45 / 180 * Math.PI) * RadiusOuter / 2), (int)(Xc + RadiusOuter), (int)(Yc + (RadiusOuter * 2))); return gp; }
public void DrawString(Node node, StyleAttributes styleAttributes, int x, int y, int dx, int dy, string text, Color color) { Brush brush1; if (styleAttributes != null) { if (node.NotBlack() || (((node.type_.type == ElementType.Entity) && (node.parent_ != null)) && node.parent_.NotBlack())) { brush1 = new SolidBrush(styleAttributes.color); } else { brush1 = new SolidBrush(color); } } else if (color != Color.Black) { brush1 = new SolidBrush(color); } else { brush1 = this.blackBrush; } System.Drawing.Font font1 = this.GetSuitableFont(node, styleAttributes); PointF tf1 = new PointF((float)((this.oX + x) + dx), (float)((this.oY + y) + dy)); if (((node.glyph != null) && node.glyph.IsVisible) && ((node.glyph.Category.Name != "Spaces") && (node.glyph.FontFamily.Length == 0))) { brush1 = new SolidBrush(Color.Red); this.graphics_.DrawString("?", font1, brush1, tf1, this.typographicsFormat); return; } if ((text == "{")) { try { double num3 = this.MeasureWidth(node, node.style_, text); double num4 = 0.1; double num5 = num4 * num3; tf1.X -= (int)Math.Round(num5); } catch { } } if (((node.type_.type == ElementType.Entity) && (node.glyph != null)) && (node.glyph.Code == "0222C")) { this.graphics_.DrawString(text, font1, brush1, tf1, this.typographicsFormat); tf1.X += node.box.Width / 3; this.graphics_.DrawString(text, font1, brush1, tf1, this.typographicsFormat); goto Label_1B94; } if (((node.type_.type == ElementType.Entity) && (node.glyph != null)) && (node.glyph.Code == "000A8")) { string text1 = ""; text1 = text + text; this.graphics_.DrawString(text1, font1, brush1, tf1, this.typographicsFormat); goto Label_1B94; } if (((node.type_.type == ElementType.Entity) && (node.glyph != null)) && (node.glyph.Code == "0222D")) { this.graphics_.DrawString(text, font1, brush1, tf1, this.typographicsFormat); tf1.X += node.box.Width / 4; this.graphics_.DrawString(text, font1, brush1, tf1, this.typographicsFormat); tf1.X += node.box.Width / 4; this.graphics_.DrawString(text, font1, brush1, tf1, this.typographicsFormat); goto Label_1B94; } if (((node.type_.type != ElementType.Entity) || (node.glyph == null)) || (((((node.glyph.Code != "02192") && (node.glyph.Code != "02190")) && ((node.glyph.Code != "02194") && (node.glyph.Code != "0F576"))) && (((node.glyph.Code != "0F577") && (node.glyph.Code != "0F578")) && ((node.glyph.Code != "021C4") && (node.glyph.Code != "021C6")))) && ((((node.glyph.Code != "021CC") && (node.glyph.Code != "021CB")) && ((node.glyph.Code != "021C0") && (node.glyph.Code != "021C1"))) && ((((node.glyph.Code != "021BC") && (node.glyph.Code != "021BD")) && ((node.glyph.Code != "0005E") && (node.glyph.Code != "000AF"))) && (((node.glyph.Code != "0FE37") && (node.glyph.Code != "0FE38")) && (node.glyph.Code != "00332")))))) { this.graphics_.DrawString(text, font1, brush1, tf1, this.typographicsFormat); goto Label_1B94; } float single1 = node.box.Width; float single2 = node.box.Height; this.graphics_.SetClip(new Rectangle((int)tf1.X, ((int)tf1.Y) - 20, node.box.Width, node.box.Height + 40)); try { PointF tf2; SizeF ef1; if (node.glyph.Code == "0FE37") { ef1 = this.graphics_.MeasureString("D", font1, tf1, this.typographicsFormat); float single3 = ef1.Width; ef1 = this.graphics_.MeasureString(text, font1, tf1, this.typographicsFormat); float single4 = ef1.Width; ef1 = this.graphics_.MeasureString("F", font1, tf1, this.typographicsFormat); float single5 = ef1.Width; ef1 = this.graphics_.MeasureString("C", font1, tf1, this.typographicsFormat); float single6 = ef1.Width; float single7 = 0f; float single8 = 0f; single8 = tf1.X; single6 -= 2f; this.graphics_.DrawString("D", font1, brush1, tf1, this.typographicsFormat); tf2 = tf1; tf2.X += single3 - 2f; single7 = single3 - 2f; int num6 = ((int)(((single1 / 2f) - (single4 / 2f)) - single3)) + 4; this.graphics_.SetClip(new Rectangle((int)tf2.X, ((int)tf2.Y) - 20, num6, node.box.Height + 40)); try { while (single7 < ((single1 / 2f) - (single4 / 2f))) { this.graphics_.DrawString("C", font1, brush1, tf2, this.typographicsFormat); tf2.X += single6; single7 += single6; } } catch { } this.graphics_.ResetClip(); tf2 = tf1; tf2.X += ((single1 / 2f) + (single4 / 2f)) - 2f; single7 = ((single1 / 2f) + (single4 / 2f)) - 2f; this.graphics_.SetClip(new Rectangle((int)tf2.X, ((int)tf2.Y) - 20, num6, node.box.Height + 40)); try { while (single7 < (single1 - single5)) { this.graphics_.DrawString("C", font1, brush1, tf2, this.typographicsFormat); tf2.X += single6; single7 += single6; } } catch { } this.graphics_.ResetClip(); tf1.X = (single8 + (single1 / 2f)) - (single4 / 2f); this.graphics_.DrawString(text, font1, brush1, tf1, this.typographicsFormat); tf1.X = (single8 + single1) - single5; this.graphics_.DrawString("F", font1, brush1, tf1, this.typographicsFormat); } else if (node.glyph.Code == "0FE38") { ef1 = this.graphics_.MeasureString("?", font1, tf1, this.typographicsFormat); float single9 = ef1.Width; ef1 = this.graphics_.MeasureString(text, font1, tf1, this.typographicsFormat); float single10 = ef1.Width; ef1 = this.graphics_.MeasureString("A", font1, tf1, this.typographicsFormat); float single11 = ef1.Width; ef1 = this.graphics_.MeasureString("C", font1, tf1, this.typographicsFormat); float single12 = ef1.Width; float single13 = 0f; float single14 = 0f; single14 = tf1.X; single12 -= 2f; this.graphics_.DrawString("?", font1, brush1, tf1, this.typographicsFormat); tf2 = tf1; tf2.X += single9 - 2f; single13 = single9 - 2f; int num7 = ((int)(((single1 / 2f) - (single10 / 2f)) - single9)) + 4; this.graphics_.SetClip(new Rectangle((int)tf2.X, ((int)tf2.Y) - 20, num7, node.box.Height + 40)); try { while (single13 < ((single1 / 2f) - (single10 / 2f))) { this.graphics_.DrawString("C", font1, brush1, tf2, this.typographicsFormat); tf2.X += single12; single13 += single12; } } catch { } this.graphics_.ResetClip(); tf2 = tf1; tf2.X += ((single1 / 2f) + (single10 / 2f)) - 2f; single13 = ((single1 / 2f) + (single10 / 2f)) - 2f; this.graphics_.SetClip(new Rectangle((int)tf2.X, ((int)tf2.Y) - 20, num7, node.box.Height + 40)); try { while (single13 < (single1 - single11)) { this.graphics_.DrawString("C", font1, brush1, tf2, this.typographicsFormat); tf2.X += single12; single13 += single12; } } catch { } this.graphics_.ResetClip(); tf1.X = (single14 + (single1 / 2f)) - (single10 / 2f); this.graphics_.DrawString(text, font1, brush1, tf1, this.typographicsFormat); tf1.X = (single14 + single1) - single11; this.graphics_.DrawString("A", font1, brush1, tf1, this.typographicsFormat); } else if (node.glyph.Code == "021C4") { ef1 = this.graphics_.MeasureString("&", font1, tf1, this.typographicsFormat); float single15 = ef1.Width; ef1 = this.graphics_.MeasureString("(", font1, tf1, this.typographicsFormat); float single16 = ef1.Width; ef1 = this.graphics_.MeasureString(text, font1, tf1, this.typographicsFormat); float single17 = ef1.Width; float single18 = 0f; this.graphics_.DrawString("&", font1, brush1, tf1, this.typographicsFormat); tf2 = tf1; tf2.X += single15; for (single18 = single15; single18 < (single1 - single17); single18 += single16) { this.graphics_.DrawString("(", font1, brush1, tf2, this.typographicsFormat); tf2.X += single16; } tf1.X = (tf1.X + single1) - single17; this.graphics_.DrawString(text, font1, brush1, tf1, this.typographicsFormat); } else if (node.glyph.Code == "021C6") { ef1 = this.graphics_.MeasureString(text, font1, tf1, this.typographicsFormat); float single19 = ef1.Width; ef1 = this.graphics_.MeasureString("(", font1, tf1, this.typographicsFormat); float single20 = ef1.Width; ef1 = this.graphics_.MeasureString(",", font1, tf1, this.typographicsFormat); float single21 = ef1.Width; float single22 = 0f; this.graphics_.DrawString(text, font1, brush1, tf1, this.typographicsFormat); tf2 = tf1; tf2.X += single19; for (single22 = single19; single22 < (single1 - single21); single22 += single20) { this.graphics_.DrawString("(", font1, brush1, tf2, this.typographicsFormat); tf2.X += single20; } tf1.X = (tf1.X + single1) - single21; this.graphics_.DrawString(",", font1, brush1, tf1, this.typographicsFormat); } else if (node.glyph.Code == "021CC") { ef1 = this.graphics_.MeasureString("2", font1, tf1, this.typographicsFormat); float single23 = ef1.Width; ef1 = this.graphics_.MeasureString("(", font1, tf1, this.typographicsFormat); float single24 = ef1.Width; ef1 = this.graphics_.MeasureString(text, font1, tf1, this.typographicsFormat); float single25 = ef1.Width; float single26 = 0f; this.graphics_.DrawString("2", font1, brush1, tf1, this.typographicsFormat); tf2 = tf1; tf2.X += single23; for (single26 = single23; single26 < (single1 - single25); single26 += single24) { this.graphics_.DrawString("(", font1, brush1, tf2, this.typographicsFormat); tf2.X += single24; } tf1.X = (tf1.X + single1) - single25; this.graphics_.DrawString(text, font1, brush1, tf1, this.typographicsFormat); } else if (node.glyph.Code == "021CB") { ef1 = this.graphics_.MeasureString(text, font1, tf1, this.typographicsFormat); float single27 = ef1.Width; ef1 = this.graphics_.MeasureString("(", font1, tf1, this.typographicsFormat); float single28 = ef1.Width; ef1 = this.graphics_.MeasureString("3", font1, tf1, this.typographicsFormat); float single29 = ef1.Width; float single30 = 0f; this.graphics_.DrawString(text, font1, brush1, tf1, this.typographicsFormat); tf2 = tf1; tf2.X += single27; for (single30 = single27; single30 < (single1 - single29); single30 += single28) { this.graphics_.DrawString("(", font1, brush1, tf2, this.typographicsFormat); tf2.X += single28; } tf1.X = (tf1.X + single1) - single29; this.graphics_.DrawString("3", font1, brush1, tf1, this.typographicsFormat); } else if ((node.glyph.Code == "02192") || (node.glyph.Code == "0F577")) { ef1 = this.graphics_.MeasureString("$", font1, tf1, this.typographicsFormat); float single31 = ef1.Width; ef1 = this.graphics_.MeasureString(text, font1, tf1, this.typographicsFormat); float single32 = ef1.Width; float single33 = 0f; single31 -= 1f; tf2 = tf1; while (single33 < (single1 - single32)) { this.graphics_.DrawString("$", font1, brush1, tf2, this.typographicsFormat); tf2.X += single31; single33 += single31; } tf1.X = (tf1.X + single1) - single32; this.graphics_.DrawString(text, font1, brush1, tf1, this.typographicsFormat); } else { if (node.glyph.Code == "0005E") { tf2 = tf1; try { ef1 = this.graphics_.MeasureString("m", font1, tf1, this.typographicsFormat); float single34 = ef1.Width; if (single1 > (single34 * 1.1)) { float single35 = single1 / 2f; single35 = (float)Math.Round((double)single35); float single36 = single2 / 3f; single36 = (float)Math.Round((double)single36); if (single36 < 1f) { single36 = 1f; } PointF tf3 = new PointF(tf2.X, tf2.Y + single2); PointF tf4 = new PointF(tf2.X + single35, tf2.Y); PointF tf5 = new PointF(tf2.X + single1, tf2.Y + single2); PointF tf6 = new PointF(tf2.X + single35, tf2.Y + single36); GraphicsPath path1 = new GraphicsPath(); path1.AddLine(tf3, tf4); path1.AddLine(tf4, tf5); path1.AddLine(tf5, tf6); path1.AddLine(tf6, tf3); this.graphics_.FillPath(brush1, path1); goto Label_1B71; } this.graphics_.DrawString(text, font1, brush1, tf2, this.typographicsFormat); goto Label_1B71; } catch { goto Label_1B71; } } if (node.glyph.Code == "000AF") { ef1 = this.graphics_.MeasureString("$", font1, tf1, this.typographicsFormat); float single37 = ef1.Width; ef1 = this.graphics_.MeasureString(text, font1, tf1, this.typographicsFormat); float single38 = ef1.Width; float single39 = 0f; tf2 = tf1; while (single39 < (single1 - single38)) { this.graphics_.DrawString("$", font1, brush1, tf2, this.typographicsFormat); tf2.X += single37; single39 += single37; } tf1.X = (tf1.X + single1) - single38; this.graphics_.DrawString(text, font1, brush1, tf1, this.typographicsFormat); } else if (node.glyph.Code == "00332") { ef1 = this.graphics_.MeasureString("$", font1, tf1, this.typographicsFormat); float single40 = ef1.Width; ef1 = this.graphics_.MeasureString(text, font1, tf1, this.typographicsFormat); float single41 = ef1.Width; float single42 = 0f; tf2 = tf1; while (single42 < (single1 - single41)) { this.graphics_.DrawString("$", font1, brush1, tf2, this.typographicsFormat); tf2.X += single40; single42 += single40; } tf1.X = (tf1.X + single1) - single41; this.graphics_.DrawString(text, font1, brush1, tf1, this.typographicsFormat); } else if ((node.glyph.Code == "021C0") || (node.glyph.Code == "021C1")) { ef1 = this.graphics_.MeasureString("$", font1, tf1, this.typographicsFormat); float single43 = ef1.Width; ef1 = this.graphics_.MeasureString(text, font1, tf1, this.typographicsFormat); float single44 = ef1.Width; float single45 = 0f; tf2 = tf1; while (single45 < (single1 - single44)) { this.graphics_.DrawString("$", font1, brush1, tf2, this.typographicsFormat); tf2.X += single43; single45 += single43; } tf1.X = (tf1.X + single1) - single44; this.graphics_.DrawString(text, font1, brush1, tf1, this.typographicsFormat); } else if ((node.glyph.Code == "021BC") || (node.glyph.Code == "021BD")) { ef1 = this.graphics_.MeasureString(text, font1, tf1, this.typographicsFormat); float single46 = ef1.Width; ef1 = this.graphics_.MeasureString("$", font1, tf1, this.typographicsFormat); float single47 = ef1.Width; float single48 = 0f; this.graphics_.DrawString(text, font1, brush1, tf1, this.typographicsFormat); tf2 = tf1; tf2.X = (tf2.X + single1) - single47; for (single48 = single1; single48 > single46; single48 -= single47) { this.graphics_.DrawString("$", font1, brush1, tf2, this.typographicsFormat); tf2.X -= single47; } } else if ((node.glyph.Code == "02190") || (node.glyph.Code == "0F576")) { ef1 = this.graphics_.MeasureString(text, font1, tf1, this.typographicsFormat); float single49 = ef1.Width; ef1 = this.graphics_.MeasureString("$", font1, tf1, this.typographicsFormat); float single50 = ef1.Width; float single51 = 0f; this.graphics_.DrawString(text, font1, brush1, tf1, this.typographicsFormat); single50 -= 1f; tf2 = tf1; tf2.X = (tf2.X + single1) - single50; for (single51 = single1; single51 > single49; single51 -= single50) { this.graphics_.DrawString("$", font1, brush1, tf2, this.typographicsFormat); tf2.X -= single50; } } else if ((node.glyph.Code == "0F578") || (node.glyph.Code == "02194")) { ef1 = this.graphics_.MeasureString("!", font1, tf1, this.typographicsFormat); float single52 = ef1.Width; ef1 = this.graphics_.MeasureString("$", font1, tf1, this.typographicsFormat); float single53 = ef1.Width; ef1 = this.graphics_.MeasureString(text, font1, tf1, this.typographicsFormat); float single54 = ef1.Width; float single55 = 0f; this.graphics_.DrawString("!", font1, brush1, tf1, this.typographicsFormat); single53 -= 1f; single52 -= 1f; tf2 = tf1; tf2.X += single52; for (single55 = single52; single55 < (single1 - single54); single55 += single53) { this.graphics_.DrawString("$", font1, brush1, tf2, this.typographicsFormat); tf2.X += single53; } tf1.X = (tf1.X + single1) - single54; this.graphics_.DrawString(text, font1, brush1, tf1, this.typographicsFormat); } } } catch { } Label_1B71: this.graphics_.ResetClip(); Label_1B94: if (!node.IsUnderlined()) { return; } int num8 = (int)this.Leading((float)node.box.Height, font1); this.graphics_.DrawLine(new Pen(brush1), this.oX + node.box.X, ((this.oY + node.box.Y) + node.box.Height) - (num8 / 2), (this.oX + node.box.X) + node.box.Width, ((this.oY + node.box.Y) + node.box.Height) - (num8 / 2)); }
/// <summary> /// Updates the line. /// </summary> /// <param name="_loc">The loc.</param> private void UpdateLine(Point _loc) { GraphicsPath path = new GraphicsPath(); double m = 0f, angle = 0f, r = -10f, x = 0f, y = 0f; if ((endPoint.Y - startPoint.Y) == 0) { x = ((endPoint.X - startPoint.X) > 0) ? 2f : ((endPoint.X - startPoint.X) < 0) ? -2f : 0f; } if ((endPoint.X - startPoint.X) == 0) { y = ((endPoint.Y - startPoint.Y) > 0) ? 2f : ((endPoint.Y - startPoint.Y) < 0) ? -2f : 0f; } Point stPoint = startPoint; Point enPoint = endPoint; if ((endPoint.Y - startPoint.Y) != 0 && (endPoint.X - startPoint.X) != 0) { m = ((double)endPoint.Y - startPoint.Y) / (endPoint.X - startPoint.X); angle = Math.Atan(m); x = r * Math.Cos(angle); y = r * Math.Sin(angle); } enPoint += new Size((int)x, (int)y); stPoint -= new Size((int)x, (int)y); path.AddLine(stPoint, enPoint); endPoint = _loc; stPoint = startPoint; enPoint = endPoint; if ((endPoint.Y - startPoint.Y) == 0) { x = ((endPoint.X - startPoint.X) > 0) ? 2f : ((endPoint.X - startPoint.X) < 0) ? -2f : 0f; } if ((endPoint.X - startPoint.X) == 0) { y = ((endPoint.Y - startPoint.Y) > 0) ? 2f : ((endPoint.Y - startPoint.Y) < 0) ? -2f : 0f; } if ((endPoint.Y - startPoint.Y) != 0 && (endPoint.X - startPoint.X) != 0) { m = ((double)endPoint.Y - startPoint.Y) / (endPoint.X - startPoint.X); angle = Math.Atan(m); x = r * Math.Cos(angle); y = r * Math.Sin(angle); } enPoint += new Size((int)x, (int)y); stPoint -= new Size((int)x, (int)y); path.AddLine(stPoint, enPoint); Pen widenPen = new Pen(Color.Black, 3f); path.Widen(widenPen); widenPen.Dispose(); Region rgn = new Region(path); Parent.Invalidate(rgn); } //Useless
/// <summary> /// 引发 <see cref="E:System.Windows.Forms.Control.Paint" /> 事件。 /// </summary> /// <param name="e">包含事件数据的 <see cref="T:System.Windows.Forms.PaintEventArgs" />。</param> protected override void OnPaint(PaintEventArgs e) { base.OnPaint(e); var g = e.Graphics; g.SetGDIHigh(); //玻璃管管 GraphicsPath path = new GraphicsPath(); path.AddLine(m_rectWorking.Left, m_rectWorking.Bottom, m_rectWorking.Left, m_rectWorking.Top + m_rectWorking.Width / 2); path.AddArc(new Rectangle(m_rectWorking.Left, m_rectWorking.Top, m_rectWorking.Width, m_rectWorking.Width), 180, 180); path.AddLine(m_rectWorking.Right, m_rectWorking.Top + m_rectWorking.Width / 2, m_rectWorking.Right, m_rectWorking.Bottom); path.CloseAllFigures(); g.FillPath(new SolidBrush(glassTubeColor), path); //底部 var rectDi = new Rectangle(this.Width / 2 - m_rectWorking.Width, m_rectWorking.Bottom - m_rectWorking.Width - 2, m_rectWorking.Width * 2, m_rectWorking.Width * 2); g.FillEllipse(new SolidBrush(glassTubeColor), rectDi); g.FillEllipse(new SolidBrush(mercuryColor), new Rectangle(rectDi.Left + 4, rectDi.Top + 4, rectDi.Width - 8, rectDi.Height - 8)); //刻度 decimal decSplit = (maxValue - minValue) / splitCount; decimal decSplitHeight = m_rectLeft.Height / splitCount; for (int i = 0; i <= splitCount; i++) { g.DrawLine(new Pen(new SolidBrush(ForeColor), 1), new PointF(m_rectLeft.Left + 2, (float)(m_rectLeft.Bottom - decSplitHeight * i)), new PointF(m_rectLeft.Right, (float)(m_rectLeft.Bottom - decSplitHeight * i))); var valueLeft = (minValue + decSplit * i).ToString("0.##"); var sizeLeft = g.MeasureString(valueLeft, Font); g.DrawString(valueLeft, Font, new SolidBrush(ForeColor), new PointF(m_rectLeft.Left, m_rectLeft.Bottom - (float)decSplitHeight * i - sizeLeft.Height - 1)); if (rightTemperatureUnit != TemperatureUnit.None) { g.DrawLine(new Pen(new SolidBrush(Color.Black), 1), new PointF(m_rectRight.Left + 2, (float)(m_rectRight.Bottom - decSplitHeight * i)), new PointF(m_rectRight.Right, (float)(m_rectRight.Bottom - decSplitHeight * i))); var valueRight = GetRightValue(minValue + decSplit * i).ToString("0.##"); var sizeRight = g.MeasureString(valueRight, Font); g.DrawString(valueRight, Font, new SolidBrush(ForeColor), new PointF(m_rectRight.Right - sizeRight.Width - 1, m_rectRight.Bottom - (float)decSplitHeight * i - sizeRight.Height - 1)); } if (i != splitCount) { if (decSplitHeight > 40) { var decSp1 = decSplitHeight / 10; for (int j = 1; j < 10; j++) { if (j == 5) { g.DrawLine(new Pen(new SolidBrush(ForeColor), 1), new PointF(m_rectLeft.Right - 10, (m_rectLeft.Bottom - (float)decSplitHeight * i - ((float)decSp1 * j))), new PointF(m_rectLeft.Right, (m_rectLeft.Bottom - (float)decSplitHeight * i - ((float)decSp1 * j)))); if (rightTemperatureUnit != TemperatureUnit.None) { g.DrawLine(new Pen(new SolidBrush(ForeColor), 1), new PointF(m_rectRight.Left + 10, (m_rectRight.Bottom - (float)decSplitHeight * i - ((float)decSp1 * j))), new PointF(m_rectRight.Left, (m_rectRight.Bottom - (float)decSplitHeight * i - ((float)decSp1 * j)))); } } else { g.DrawLine(new Pen(new SolidBrush(ForeColor), 1), new PointF(m_rectLeft.Right - 5, (m_rectLeft.Bottom - (float)decSplitHeight * i - ((float)decSp1 * j))), new PointF(m_rectLeft.Right, (m_rectLeft.Bottom - (float)decSplitHeight * i - ((float)decSp1 * j)))); if (rightTemperatureUnit != TemperatureUnit.None) { g.DrawLine(new Pen(new SolidBrush(ForeColor), 1), new PointF(m_rectRight.Left + 5, (m_rectRight.Bottom - (float)decSplitHeight * i - ((float)decSp1 * j))), new PointF(m_rectRight.Left, (m_rectRight.Bottom - (float)decSplitHeight * i - ((float)decSp1 * j)))); } } } } else if (decSplitHeight > 10) { g.DrawLine(new Pen(new SolidBrush(ForeColor), 1), new PointF(m_rectLeft.Right - 5, (m_rectLeft.Bottom - (float)decSplitHeight * i - (float)decSplitHeight / 2)), new PointF(m_rectLeft.Right, (m_rectLeft.Bottom - (float)decSplitHeight * i - (float)decSplitHeight / 2))); if (rightTemperatureUnit != TemperatureUnit.None) { g.DrawLine(new Pen(new SolidBrush(ForeColor), 1), new PointF(m_rectRight.Left + 5, (m_rectRight.Bottom - (float)decSplitHeight * i - (float)decSplitHeight / 2)), new PointF(m_rectRight.Left, (m_rectRight.Bottom - (float)decSplitHeight * i - (float)decSplitHeight / 2))); } } } } //单位 string strLeftUnit = GetUnitChar(leftTemperatureUnit); g.DrawString(strLeftUnit, Font, new SolidBrush(ForeColor), new PointF(m_rectLeft.Left + 2, 2)); if (rightTemperatureUnit != TemperatureUnit.None) { string strRightUnit = GetUnitChar(rightTemperatureUnit); var rightSize = g.MeasureString(strRightUnit, Font); g.DrawString(strRightUnit, Font, new SolidBrush(ForeColor), new PointF(m_rectRight.Right - 2 - rightSize.Width, 2)); } //值 float fltHeightValue = (float)(Value / (maxValue - minValue) * m_rectLeft.Height); RectangleF rectValue = new RectangleF(m_rectWorking.Left + 4, m_rectLeft.Top + (m_rectLeft.Height - fltHeightValue), m_rectWorking.Width - 8, fltHeightValue + (m_rectWorking.Height - m_rectWorking.Width / 2 - m_rectLeft.Height)); g.FillRectangle(new SolidBrush(mercuryColor), rectValue); var sizeValue = g.MeasureString(m_value.ToString("0.##"), Font); g.DrawString(m_value.ToString("0.##"), Font, new SolidBrush(Color.White), new PointF(rectDi.Left + (rectDi.Width - sizeValue.Width) / 2, rectDi.Top + (rectDi.Height - sizeValue.Height) / 2 + 1)); }
/// <summary> /// 建立带有圆角样式的路径。 /// </summary> /// <param name="rect">用来建立路径的矩形。</param> /// <param name="_radius">圆角的大小。</param> /// <param name="style">圆角的样式。</param> /// <param name="correction">是否把矩形长宽减 1,以便画出边框。</param> /// <returns>建立的路径。</returns> public static GraphicsPath CreatePath(Rectangle rect, int radius, RoundStyle style, bool correction) { GraphicsPath path = new GraphicsPath(); int radiusCorrection = correction ? 1 : 0; switch (style) { case RoundStyle.None: path.AddRectangle(rect); break; case RoundStyle.All: path.AddArc(rect.X, rect.Y, radius, radius, 180, 90); path.AddArc( rect.Right - radius - radiusCorrection, rect.Y, radius, radius, 270, 90); path.AddArc( rect.Right - radius - radiusCorrection, rect.Bottom - radius - radiusCorrection, radius, radius, 0, 90); path.AddArc( rect.X, rect.Bottom - radius - radiusCorrection, radius, radius, 90, 90); break; case RoundStyle.Left: path.AddArc(rect.X, rect.Y, radius, radius, 180, 90); path.AddLine( rect.Right - radiusCorrection, rect.Y, rect.Right - radiusCorrection, rect.Bottom - radiusCorrection); path.AddArc( rect.X, rect.Bottom - radius - radiusCorrection, radius, radius, 90, 90); break; case RoundStyle.Right: path.AddArc( rect.Right - radius - radiusCorrection, rect.Y, radius, radius, 270, 90); path.AddArc( rect.Right - radius - radiusCorrection, rect.Bottom - radius - radiusCorrection, radius, radius, 0, 90); path.AddLine(rect.X, rect.Bottom - radiusCorrection, rect.X, rect.Y); break; case RoundStyle.Top: path.AddArc(rect.X, rect.Y, radius, radius, 180, 90); path.AddArc( rect.Right - radius - radiusCorrection, rect.Y, radius, radius, 270, 90); path.AddLine( rect.Right - radiusCorrection, rect.Bottom - radiusCorrection, rect.X, rect.Bottom - radiusCorrection); break; case RoundStyle.Bottom: path.AddArc( rect.Right - radius - radiusCorrection, rect.Bottom - radius - radiusCorrection, radius, radius, 0, 90); path.AddArc( rect.X, rect.Bottom - radius - radiusCorrection, radius, radius, 90, 90); path.AddLine(rect.X, rect.Y, rect.Right - radiusCorrection, rect.Y); break; case RoundStyle.BottomLeft: path.AddArc( rect.X, rect.Bottom - radius - radiusCorrection, radius, radius, 90, 90); path.AddLine(rect.X, rect.Y, rect.Right - radiusCorrection, rect.Y); path.AddLine( rect.Right - radiusCorrection, rect.Y, rect.Right - radiusCorrection, rect.Bottom - radiusCorrection); break; case RoundStyle.BottomRight: path.AddArc( rect.Right - radius - radiusCorrection, rect.Bottom - radius - radiusCorrection, radius, radius, 0, 90); path.AddLine(rect.X, rect.Bottom - radiusCorrection, rect.X, rect.Y); path.AddLine(rect.X, rect.Y, rect.Right - radiusCorrection, rect.Y); break; } path.CloseFigure(); return(path); }
// Snippet by RodStephens private GraphicsPath RoundedRect(RectangleF rect, float x_radius, float y_radius, bool round_upperLeft, bool round_upperRight, bool round_lowerRight, bool round_lowerLeft) { PointF point1, point2; var path = new GraphicsPath(); // Upper left corner if (round_upperLeft) { var corner = new RectangleF(rect.X, rect.Y, 2 * x_radius, 2 * y_radius); path.AddArc(corner, 180, 90); point1 = new PointF(rect.X + x_radius, rect.Y); } else { point1 = new PointF(rect.X, rect.Y); } // Top side if (round_upperRight) { point2 = new PointF(rect.Right - x_radius, rect.Y); } else { point2 = new PointF(rect.Right, rect.Y); path.AddLine(point1, point2); } // Upper right corner if (round_upperRight) { var corner = new RectangleF(rect.Right - 2 * x_radius, rect.Y, 2 * x_radius, 2 * y_radius); path.AddArc(corner, 270, 90); point1 = new PointF(rect.Right, rect.Y + y_radius); } else { point1 = new PointF(rect.Right, rect.Y); } // Right side if (round_lowerRight) { point2 = new PointF(rect.Right, rect.Bottom - y_radius); } else { point2 = new PointF(rect.Right, rect.Bottom); path.AddLine(point1, point2); } // Lower right corner if (round_lowerRight) { var corner = new RectangleF(rect.Right - 2 * x_radius, rect.Bottom - 2 * y_radius, 2 * x_radius, 2 * y_radius); path.AddArc(corner, 0, 90); point1 = new PointF(rect.Right - x_radius, rect.Bottom); } else { point1 = new PointF(rect.Right, rect.Bottom); } // Bottom side if (round_lowerLeft) { point2 = new PointF(rect.X + x_radius, rect.Bottom); } else { point2 = new PointF(rect.X, rect.Bottom); path.AddLine(point1, point2); } // Lower left corner if (round_lowerLeft) { var corner = new RectangleF(rect.X, rect.Bottom - 2 * y_radius, 2 * x_radius, 2 * y_radius); path.AddArc(corner, 90, 90); point1 = new PointF(rect.X, rect.Bottom - y_radius); } else { point1 = new PointF(rect.X, rect.Bottom); } // Left side if (round_upperLeft) { point2 = new PointF(rect.X, rect.Y + y_radius); } else { point2 = new PointF(rect.X, rect.Y); path.AddLine(point1, point2); } path.CloseFigure(); return(path); }
/// <summary> /// </summary> /// <param name="graphics"></param> /// <param name="bounds"></param> /// <param name="min"></param> /// <param name="max"></param> public override void Plot(Graphics graphics, Rectangle bounds, double min, double max) { if (Bars == null || ChartControl == null) { return; } // plot error if data not complete if (textBrush.Color != ChartControl.AxisColor || textFont != ChartControl.Font) { textBrush.Color = ChartControl.AxisColor; textFont = ChartControl.Font; SizeF errorSize = graphics.MeasureString(errorData, textFont); errorTextWidth = errorSize.Width + 5; errorTextHeight = errorSize.Height + 5; } if (priorDayHLC == HLCCalculationMode.CalcFromIntradayData) { DateTime lastBarDate = (Bars.Count == 0) ? Cbi.Globals.MaxDate : ChartControl.EquidistantBars ? Bars.GetTime(Math.Min(Bars.Count - 1, ChartControl.LastBarPainted)).Date : Bars.GetTime(Math.Min(Bars.Count - 1, Bars.GetBar(ChartControl.LastBarTimePainted))).Date; if ((lastBarDate == Cbi.Globals.MaxDate) || (Bars.BarsType.BuiltFrom == PeriodType.Minute && ((pivotRangeType == PivotRange.Monthly && Bars.Count > 0 && Bars.GetTime(0).AddSeconds(-1).Date >= new DateTime(lastBarDate.Year, lastBarDate.Month, 1).AddMonths(-1)) || (pivotRangeType == PivotRange.Weekly && Bars.Count > 0 && Bars.GetTime(0).AddSeconds(-1).Date >= lastBarDate.AddDays(-(((int)lastBarDate.DayOfWeek) + 1) % 7).AddDays(-7)) || (pivotRangeType == PivotRange.Daily && Bars.Count > 0 && Bars.GetTime(0).AddSeconds(-1).Date >= lastBarDate.AddDays(-1)))) || (Bars.BarsType.BuiltFrom != PeriodType.Minute && ((pivotRangeType == PivotRange.Monthly && Bars.Count > 0 && Bars.GetTime(0).Date >= new DateTime(lastBarDate.Year, lastBarDate.Month, 1).AddMonths(-1)) || (pivotRangeType == PivotRange.Weekly && Bars.Count > 0 && Bars.GetTime(0).Date >= lastBarDate.AddDays(-(((int)lastBarDate.DayOfWeek) + 1) % 7).AddDays(-7)) || (pivotRangeType == PivotRange.Daily && Bars.Count > 0 && Bars.GetTime(0).Date >= lastBarDate.AddDays(-1))))) { graphics.DrawString(errorData, ChartControl.Font, textBrush, bounds.X + bounds.Width - errorTextWidth, bounds.Y + bounds.Height - errorTextHeight, stringFormatNear); } } else if (priorDayHLC == HLCCalculationMode.DailyBars && existsHistDailyData) { DateTime lastBarDate = (dailyBars.Count == 0) ? Cbi.Globals.MaxDate : ChartControl.EquidistantBars ? dailyBars.GetTime(Math.Min(dailyBars.Count - 1, ChartControl.LastBarPainted)).Date : dailyBars.GetTime(Math.Min(dailyBars.Count - 1, dailyBars.GetBar(ChartControl.LastBarTimePainted))).Date; if ((lastBarDate == Cbi.Globals.MaxDate) || (pivotRangeType == PivotRange.Monthly && dailyBars.GetTime(0).Date >= new DateTime(lastBarDate.Year, lastBarDate.Month, 1).AddMonths(-1)) || (pivotRangeType == PivotRange.Weekly && dailyBars.GetTime(0).Date >= lastBarDate.AddDays(-(((int)lastBarDate.DayOfWeek) + 1) % 7).AddDays(-7)) || (pivotRangeType == PivotRange.Daily && dailyBars.GetTime(0).Date >= lastBarDate.AddDays(-1))) { graphics.DrawString(errorData, ChartControl.Font, textBrush, bounds.X + bounds.Width - errorTextWidth, bounds.Y + bounds.Height - errorTextHeight, stringFormatNear); } } float textHeight = ChartControl.Font.GetHeight(); for (int seriesCount = 0; seriesCount < Values.Length; seriesCount++) { SolidBrush brush = brushes[seriesCount]; int firstBarIdxToPaint = -1; int lastX = -1; int lastY = -1; SmoothingMode oldSmoothingMode = graphics.SmoothingMode; Gui.Chart.Plot plot = Plots[seriesCount]; DataSeries series = (DataSeries)Values[seriesCount]; for (int i = newSessionBarIdxArr.Count - 1; i >= 0; i--) { int prevSessionBreakIdx = (int)newSessionBarIdxArr[i]; if (prevSessionBreakIdx <= this.LastBarIndexPainted) { firstBarIdxToPaint = prevSessionBreakIdx; break; } } using (GraphicsPath path = new GraphicsPath()) { if (brush.Color != plot.Pen.Color) { brush = new SolidBrush(plot.Pen.Color); } for (int idx = this.LastBarIndexPainted; idx >= Math.Max(this.FirstBarIndexPainted, this.LastBarIndexPainted - Width); idx--) { if (idx - Displacement < 0 || idx - Displacement >= Bars.Count || (!ChartControl.ShowBarsRequired && idx - Displacement < BarsRequired)) { continue; } else if (!series.IsValidPlot(idx)) { continue; } if (idx < firstBarIdxToPaint) { break; } double val = series.Get(idx); int x = ChartControl.GetXByBarIdx(BarsArray[0], idx); int y = ChartControl.GetYByValue(this, val); if (lastX >= 0) { if (y != lastY) // Problem here is, that last bar of old day has date of new day { y = lastY; } path.AddLine(lastX - plot.Pen.Width / 2, lastY, x - plot.Pen.Width / 2, y); } lastX = x; lastY = y; } graphics.SmoothingMode = SmoothingMode.AntiAlias; graphics.DrawPath(plot.Pen, path); graphics.SmoothingMode = oldSmoothingMode; graphics.DrawString(plot.Name, ChartControl.Font, brush, lastX, lastY - textHeight / 2, stringFormatFar); } } }
public static GraphicsPath Create(int x, int y, int width, int height, int radius, RectangleCorners corners) { int xw = x + width; int yh = y + height; int xwr = xw - radius; int yhr = yh - radius; int xr = x + radius; int yr = y + radius; int r2 = radius * 2; int xwr2 = xw - r2; int yhr2 = yh - r2; GraphicsPath p = new GraphicsPath(); p.StartFigure(); //Top Left Corner if ((RectangleCorners.TopLeft & corners) == RectangleCorners.TopLeft) { p.AddArc(x, y, r2, r2, 180, 90); } else { p.AddLine(x, yr, x, y); p.AddLine(x, y, xr, y); } //Top Edge p.AddLine(xr, y, xwr, y); //Top Right Corner if ((RectangleCorners.TopRight & corners) == RectangleCorners.TopRight) { p.AddArc(xwr2, y, r2, r2, 270, 90); } else { p.AddLine(xwr, y, xw, y); p.AddLine(xw, y, xw, yr); } //Right Edge p.AddLine(xw, yr, xw, yhr); //Bottom Right Corner if ((RectangleCorners.BottomRight & corners) == RectangleCorners.BottomRight) { p.AddArc(xwr2, yhr2, r2, r2, 0, 90); } else { p.AddLine(xw, yhr, xw, yh); p.AddLine(xw, yh, xwr, yh); } //Bottom Edge p.AddLine(xwr, yh, xr, yh); //Bottom Left Corner if ((RectangleCorners.BottomLeft & corners) == RectangleCorners.BottomLeft) { p.AddArc(x, yhr2, r2, r2, 90, 90); } else { p.AddLine(xr, yh, x, yh); p.AddLine(x, yh, x, yhr); } //Left Edge p.AddLine(x, yhr, x, yr); p.CloseFigure(); return(p); }
private static GraphicsPath GenerateRoundedRectangle(this Graphics graphics, RectangleF rectangle, float radius, RectangleEdgeFilter filter) { float diameter; GraphicsPath path = new GraphicsPath(); if (radius <= 0.0F || filter == RectangleEdgeFilter.None) { path.AddRectangle(rectangle); path.CloseFigure(); return(path); } else { if (radius >= (Math.Min(rectangle.Width, rectangle.Height)) / 2.0) { return(graphics.GenerateCapsule(rectangle)); } diameter = radius * 2.0F; SizeF sizeF = new SizeF(diameter, diameter); RectangleF arc = new RectangleF(rectangle.Location, sizeF); if ((RectangleEdgeFilter.TopLeft & filter) == RectangleEdgeFilter.TopLeft) { path.AddArc(arc, 180, 90); } else { path.AddLine(arc.X, arc.Y + arc.Height, arc.X, arc.Y); path.AddLine(arc.X, arc.Y, arc.X + arc.Width, arc.Y); } arc.X = rectangle.Right - diameter; if ((RectangleEdgeFilter.TopRight & filter) == RectangleEdgeFilter.TopRight) { path.AddArc(arc, 270, 90); } else { path.AddLine(arc.X, arc.Y, arc.X + arc.Width, arc.Y); path.AddLine(arc.X + arc.Width, arc.Y + arc.Height, arc.X + arc.Width, arc.Y); } arc.Y = rectangle.Bottom - diameter; if ((RectangleEdgeFilter.BottomRight & filter) == RectangleEdgeFilter.BottomRight) { path.AddArc(arc, 0, 90); } else { path.AddLine(arc.X + arc.Width, arc.Y, arc.X + arc.Width, arc.Y + arc.Height); path.AddLine(arc.X, arc.Y + arc.Height, arc.X + arc.Width, arc.Y + arc.Height); } arc.X = rectangle.Left; if ((RectangleEdgeFilter.BottomLeft & filter) == RectangleEdgeFilter.BottomLeft) { path.AddArc(arc, 90, 90); } else { path.AddLine(arc.X + arc.Width, arc.Y + arc.Height, arc.X, arc.Y + arc.Height); path.AddLine(arc.X, arc.Y + arc.Height, arc.X, arc.Y); } path.CloseFigure(); } return(path); }
public static void Main () { Bitmap bmp = new Bitmap (600, 300); Graphics dc = Graphics.FromImage (bmp); Font fnt = new Font ("Arial", 8); Font fnttitle = new Font ("Arial", 8, FontStyle.Underline); Matrix matrix = new Matrix (); GraphicsPath patha = new GraphicsPath (); GraphicsPath pathb = new GraphicsPath (); Pen redPen = new Pen (Color.Red, 2); Region rgn1; Region rgn2; int x = 0; SolidBrush whiteBrush = new SolidBrush (Color.White); dc.DrawString ("Region samples using GraphicsPath", fnttitle, whiteBrush, 5, 5); /* First*/ patha.AddLine (60, 40, 90, 90); patha.AddLine (90, 90, 10, 90); patha.AddLine (10, 90, 60, 40); dc.DrawPath (redPen, patha); pathb.AddEllipse(30, 55, 60, 60); dc.DrawPath(redPen, pathb); rgn1 = new Region (patha); rgn2 = new Region (pathb); rgn1.Complement (rgn2); dc.FillRegion (Brushes.Blue, rgn1); dc.DrawString ("Complement (" + rgn1.GetRegionScans (matrix).Length +")", fnt, whiteBrush, 10, 140); dc.DrawRectangles (Pens.Yellow, rgn1.GetRegionScans (matrix)); x += 110; /* Second*/ patha.Reset (); pathb.Reset (); patha.AddLine (60+x, 40, 90+x, 90); patha.AddLine (90+x, 90, 10+x, 90); patha.AddLine (10+x, 90, 60+x, 40); dc.DrawPath (redPen, patha); pathb.AddEllipse (30+x, 55, 60, 60); dc.DrawPath(redPen, pathb); rgn1 = new Region (patha); rgn2 = new Region (pathb); rgn1.Exclude (rgn2); dc.FillRegion (Brushes.Blue, rgn1); dc.DrawString ("Exclude (" + rgn1.GetRegionScans (matrix).Length +")", fnt, whiteBrush, 140, 140); dc.DrawRectangles (Pens.Yellow, rgn1.GetRegionScans (matrix)); x += 110; /* Third*/ patha.Reset (); pathb.Reset (); patha.AddLine (60+x, 40, 90+x, 90); patha.AddLine (90+x, 90, 10+x, 90); patha.AddLine (10+x, 90, 60+x, 40); dc.DrawPath (redPen, patha); pathb.AddEllipse (30+x, 55, 60, 60); dc.DrawPath (redPen, pathb); rgn1 = new Region (patha); rgn2 = new Region (pathb); rgn1.Intersect (rgn2); dc.FillRegion (Brushes.Blue, rgn1); dc.DrawString ("Intersect (" + rgn1.GetRegionScans (matrix).Length +")", fnt, whiteBrush, 270, 140); dc.DrawRectangles (Pens.Yellow, rgn1.GetRegionScans (matrix)); x += 110; /* Four*/ patha.Reset (); pathb.Reset (); patha.AddLine (60+x, 40, 90+x, 90); patha.AddLine (90+x, 90, 10+x, 90); patha.AddLine (10+x, 90, 60+x, 40); dc.DrawPath (redPen, patha); pathb.AddEllipse (30+x, 55, 60, 60); dc.DrawPath (redPen, pathb); rgn1 = new Region (patha); rgn2 = new Region (pathb); rgn1.Xor (rgn2); dc.FillRegion(Brushes.Blue, rgn1); dc.DrawString ("Xor (" + rgn1.GetRegionScans (matrix).Length +")", fnt, whiteBrush, 380, 140); dc.DrawRectangles (Pens.Yellow, rgn1.GetRegionScans (matrix)); x += 110; /* Fifth */ patha.Reset (); pathb.Reset (); patha.AddLine (60+x, 40, 90+x, 90); patha.AddLine (90+x, 90, 10+x, 90); patha.AddLine (10+x, 90, 60+x, 40); dc.DrawPath (redPen, patha); pathb.AddEllipse (30+x, 55, 60, 60); dc.DrawPath (redPen, pathb); rgn1 = new Region (patha); rgn2 = new Region (pathb); rgn1.Union (rgn2); dc.FillRegion(Brushes.Blue, rgn1); dc.DrawRectangles (Pens.Yellow, rgn1.GetRegionScans (matrix)); dc.DrawString ("Union (" + rgn1.GetRegionScans (matrix).Length +")", fnt, whiteBrush, 490, 140); bmp.Save("regionsgp.bmp", ImageFormat.Bmp); }
protected override void OnPaint(PaintEventArgs pevent) { //base.OnPaint(pevent); if (inOnPaint) { return; } inOnPaint = true; try { Graphics gr = pevent.Graphics; gr.Clear(this.BackColor); gr.SmoothingMode = SmoothingMode.AntiAlias; Rectangle outside = new Rectangle(0, 0, this.Width, this.Height); LinearGradientBrush linear = new LinearGradientBrush(outside, BGGradTop, BGGradBot, LinearGradientMode.Vertical); Pen mypen = new Pen(Outline, 1); GraphicsPath outline = new GraphicsPath(); float wid = this.Height / 3f; wid = 1; int width = this.Width - 1; int height = this.Height - 1; // tl outline.AddArc(0, 0, wid, wid, 180, 90); // top line outline.AddLine(wid, 0, width - wid, 0); // tr outline.AddArc(width - wid, 0, wid, wid, 270, 90); // br outline.AddArc(width - wid, height - wid, wid, wid, 0, 90); // bottom line outline.AddLine(wid, height, width - wid, height); // bl outline.AddArc(0, height - wid, wid, wid, 90, 90); // left line outline.AddLine(0, height - wid, 0, wid - wid / 2); gr.FillPath(linear, outline); gr.DrawPath(mypen, outline); SolidBrush mybrush = new SolidBrush(TextColor); if (_mouseover) { SolidBrush brush = new SolidBrush(ColorMouseOver); gr.FillPath(brush, outline); } if (_mousedown) { SolidBrush brush = new SolidBrush(ColorMouseDown); gr.FillPath(brush, outline); } if (!this.Enabled) { SolidBrush brush = new SolidBrush(_ColorNotEnabled); gr.FillPath(brush, outline); } StringFormat stringFormat = new StringFormat(); stringFormat.Alignment = StringAlignment.Center; stringFormat.LineAlignment = StringAlignment.Center; string display = this.Text; int amppos = display.IndexOf('&'); if (amppos != -1) { display = display.Remove(amppos, 1); } gr.DrawString(display, this.Font, mybrush, outside, stringFormat); } catch { } inOnPaint = false; }
private GraphicsPath RoundRect(RectangleF r, float r1, float r2, float r3, float r4) { float x = r.X, y = r.Y, w = r.Width, h = r.Height; GraphicsPath rr = new GraphicsPath(); rr.AddBezier(x, y + r1, x, y, x + r1, y, x + r1, y); rr.AddLine(x + r1, y, x + w - r2, y); rr.AddBezier(x + w - r2, y, x + w, y, x + w, y + r2, x + w, y + r2); rr.AddLine(x + w, y + r2, x + w, y + h - r3); rr.AddBezier(x + w, y + h - r3, x + w, y + h, x + w - r3, y + h, x + w - r3, y + h); rr.AddLine(x + w - r3, y + h, x + r4, y + h); rr.AddBezier(x + r4, y + h, x, y + h, x, y + h - r4, x, y + h - r4); rr.AddLine(x, y + h - r4, x, y + r1); return rr; }
private static GraphicsPath CreateRoundRectangle(Rectangle rectangle, int radius, RoundCornerStyle rcStyle) { GraphicsPath path = new GraphicsPath(); int l = rectangle.Left; int t = rectangle.Top; int w = rectangle.Width; int h = rectangle.Height; if (radius <= 0) { path.AddLine(l, t, l + w, t); // top path.AddLine(l + w, t, l + w, t + h); // right path.AddLine(l + w, t + h, l, t + h); // bottom path.AddLine(l, t + h, l, t); // left } else { int d = radius << 1; int lefttop_eff = 0; int leftbtm_eff = 0; int righttop_eff = 0; int rightbtm_eff = 0; int topleft_eff = 0; int topright_eff = 0; int btmleft_eff = 0; int btmright_eff = 0; if ((rcStyle & RoundCornerStyle.LeftTop) == RoundCornerStyle.LeftTop) { lefttop_eff = radius; topleft_eff = radius; } if ((rcStyle & RoundCornerStyle.RightTop) == RoundCornerStyle.RightTop) { righttop_eff = radius; topright_eff = radius; } if ((rcStyle & RoundCornerStyle.RightBottom) == RoundCornerStyle.RightBottom) { btmright_eff = radius; rightbtm_eff = radius; } if ((rcStyle & RoundCornerStyle.LeftBottom) == RoundCornerStyle.LeftBottom) { leftbtm_eff = radius; btmleft_eff = radius; } if ((rcStyle & RoundCornerStyle.LeftTop) == RoundCornerStyle.LeftTop) { path.AddArc(l, t, d, d, 180, 90); // topleft } path.AddLine(l + lefttop_eff, t, l + w - righttop_eff, t); // top if ((rcStyle & RoundCornerStyle.RightTop) == RoundCornerStyle.RightTop) { path.AddArc(l + w - d, t, d, d, 270, 90); // topright } path.AddLine(l + w, t + topright_eff, l + w, t + h - btmright_eff); // right if ((rcStyle & RoundCornerStyle.RightBottom) == RoundCornerStyle.RightBottom) { path.AddArc(l + w - d, t + h - d, d, d, 0, 90); // bottomright } path.AddLine(l + w - rightbtm_eff, t + h, l + leftbtm_eff, t + h); // bottom if ((rcStyle & RoundCornerStyle.LeftBottom) == RoundCornerStyle.LeftBottom) { path.AddArc(l, t + h - d, d, d, 90, 90); // bottomleft } path.AddLine(l, t + h - btmleft_eff, l, t + topleft_eff); // left } path.CloseFigure(); return(path); }
// REAL MAGIC HERE! y- B- private void DrawData(Graphics g, float Xunit, float Yunit,int xstart ) { PeptideMW PMW = new PeptideMW(PeptideSequence); float[] Bs = PMW.GetPepFragmentBValues(); float[] Ys = PMW.GetPepFragmentYValues(); bool bPhos = PMW.IsPhosphorylation(); int Count = SpectrumData.Count; int i = 0; for (i = 0; i < Count; i++) { float mz = ((MZintensitiy )SpectrumData[i]).mz ; float intensity = ((MZintensitiy )SpectrumData[i]).intensity ; float x = (mz - xstart)*Xunit + NETAREALEFTMARGIN ; float y; if (bZoomOut) { if (intensity * 100 / MaxIntensitiy > DisplayMaxY) { y = NETAREATOPMARGIN ; } else { y = HEIGHT - NETAREABOTTOMMARGIN - intensity * 100 * Yunit / MaxIntensitiy; } } else y = HEIGHT - NETAREABOTTOMMARGIN - intensity * 100 * Yunit / MaxIntensitiy; Pen dataPen = new Pen (Brushes.Black ,1); Pen BLinePen = new Pen(Brushes.Blue, 2); Pen YLinePen = new Pen(Brushes.Red, 2); Pen ALinePen = new Pen (Brushes.Green ,2); Pen MLinePen = new Pen(Brushes.Gray , 2); Font Numberfont = new Font("Arial", 9, FontStyle.Regular); if (y < HEIGHT - NETAREABOTTOMMARGIN -20 && bShowLabel ) { string strAnn = GetAnnotation(SpectrumData,i, Bs, Ys,PrecursorMZ,int.Parse (ChargeState ),bPhos ); if (strAnn.StartsWith("(b")) { g.DrawLine(BLinePen, x, y, x, (float)HEIGHT - NETAREABOTTOMMARGIN); g.DrawString(strAnn, Numberfont, Brushes.Blue , new PointF(x, y)); } else if (strAnn.StartsWith("(y")) { g.DrawLine(YLinePen, x, y, x, (float)HEIGHT - NETAREABOTTOMMARGIN); g.DrawString(strAnn, Numberfont, Brushes.Red, new PointF(x, y)); } else if (strAnn.StartsWith("(a")) { g.DrawLine(ALinePen, x, y, x, (float)HEIGHT - NETAREABOTTOMMARGIN); g.DrawString(strAnn, Numberfont, Brushes.Green, new PointF(x, y)); } else if (strAnn.StartsWith("(M") && y < HEIGHT - NETAREABOTTOMMARGIN -100) { g.DrawLine(MLinePen, x, y, x, (float)HEIGHT - NETAREABOTTOMMARGIN); g.DrawString(strAnn, Numberfont, Brushes.Gray , new PointF(x, y)); } else { g.DrawLine(dataPen, x, y, x, (float)HEIGHT - NETAREABOTTOMMARGIN); } //g.DrawString(strAnn, Numberfont, Brushes.Red, new PointF(x, y)); } else g.DrawLine(dataPen, x, y, x, (float)HEIGHT - NETAREABOTTOMMARGIN); if (intensity == MaxIntensitiy) { //peak value point GraphicsPath p = new GraphicsPath(); p.AddLine(x, (float)HEIGHT - NETAREABOTTOMMARGIN, x + XAxisScaleLength, (float)HEIGHT - NETAREABOTTOMMARGIN + XAxisScaleLength); p.AddLine(x + XAxisScaleLength, (float)HEIGHT - NETAREABOTTOMMARGIN + XAxisScaleLength, x - XAxisScaleLength, (float)HEIGHT - NETAREABOTTOMMARGIN + XAxisScaleLength); p.CloseFigure(); g.FillPath(Brushes.Red, p); g.DrawString(mz.ToString(), Numberfont, Brushes.Red, x + XAxisScaleLength, (float)HEIGHT - NETAREABOTTOMMARGIN); } } }
private GraphicsPath MakeRoundedRect( RectangleF rect, float xradius, float yradius, bool round_ul, bool round_ur, bool round_lr, bool round_ll) { // Make a GraphicsPath to draw the rectangle. PointF point1, point2; GraphicsPath path = new GraphicsPath(); // Upper left corner. if (round_ul) { RectangleF corner = new RectangleF( rect.X, rect.Y, 2 * xradius, 2 * yradius); path.AddArc(corner, 180, 90); point1 = new PointF(rect.X + xradius, rect.Y); } else { point1 = new PointF(rect.X, rect.Y); } // Top side. if (round_ur) { point2 = new PointF(rect.Right - xradius, rect.Y); } else { point2 = new PointF(rect.Right, rect.Y); } path.AddLine(point1, point2); // Upper right corner. if (round_ur) { RectangleF corner = new RectangleF( rect.Right - 2 * xradius, rect.Y, 2 * xradius, 2 * yradius); path.AddArc(corner, 270, 90); point1 = new PointF(rect.Right, rect.Y + yradius); } else { point1 = new PointF(rect.Right, rect.Y); } // Right side. if (round_lr) { point2 = new PointF(rect.Right, rect.Bottom - yradius); } else { point2 = new PointF(rect.Right, rect.Bottom); } path.AddLine(point1, point2); // Lower right corner. if (round_lr) { RectangleF corner = new RectangleF( rect.Right - 2 * xradius, rect.Bottom - 2 * yradius, 2 * xradius, 2 * yradius); path.AddArc(corner, 0, 90); point1 = new PointF(rect.Right - xradius, rect.Bottom); } else { point1 = new PointF(rect.Right, rect.Bottom); } // Bottom side. if (round_ll) { point2 = new PointF(rect.X + xradius, rect.Bottom); } else { point2 = new PointF(rect.X, rect.Bottom); } path.AddLine(point1, point2); // Lower left corner. if (round_ll) { RectangleF corner = new RectangleF( rect.X, rect.Bottom - 2 * yradius, 2 * xradius, 2 * yradius); path.AddArc(corner, 90, 90); point1 = new PointF(rect.X, rect.Bottom - yradius); } else { point1 = new PointF(rect.X, rect.Bottom); } // Left side. if (round_ul) { point2 = new PointF(rect.X, rect.Y + yradius); } else { point2 = new PointF(rect.X, rect.Y); } path.AddLine(point1, point2); // Join with the start point. path.CloseFigure(); return(path); }
private Region CreateRoundedRectangleRegion(int radius, Rectangle rectangle) { using (GraphicsPath Path = new GraphicsPath()) { int Radius2 = (radius * 2); Path.FillMode = FillMode.Winding; Path.StartFigure(); Path.AddArc(rectangle.X, rectangle.Y, Radius2, Radius2, 180, 90); Path.AddLine(rectangle.X + radius, rectangle.Y, rectangle.Right - radius, rectangle.Y); Path.AddArc(rectangle.Right - Radius2 - 1, rectangle.Y, Radius2, Radius2, 270, 90); Path.AddLine(rectangle.Right, rectangle.Y + radius, rectangle.Right, rectangle.Bottom - radius); Path.AddArc(rectangle.Right - Radius2 - 1, rectangle.Bottom - Radius2 - 1, Radius2, Radius2, 0, 90); Path.AddLine(rectangle.Right - radius, rectangle.Bottom, rectangle.X + radius, rectangle.Bottom); Path.AddArc(rectangle.X, rectangle.Bottom - Radius2 - 1, Radius2, Radius2, 90, 90); Path.AddLine(rectangle.X, rectangle.Bottom - radius, rectangle.X, rectangle.Y + radius); Path.CloseFigure(); return new Region(Path); } }
private void DrawGlowingNeedle(Dictionary <float, float> angleLut, float value, Color bOut, Color bGlow, Color bIn, Graphics g) { var angleStart = angleLut.Values.FirstOrDefault(); var angleSweep = float.MaxValue; if (value < 0) { value = 0; } var lastK = 0.0f; var lastV = 0.0f; foreach (var kvp in angleLut) { if (kvp.Key >= value) { var d = kvp.Key - lastK; var s = kvp.Value - lastV; var duty = (value - lastK) / d; angleSweep = s * duty + lastV; break; } else { lastK = kvp.Key; lastV = kvp.Value; } } if (float.IsNaN(angleSweep)) { angleSweep = angleStart; } if (float.MaxValue == angleSweep) { angleSweep = angleLut.Values.LastOrDefault(); } angleSweep -= angleStart; if (Math.Abs(angleSweep) < 0.1f) { angleSweep = 0.1f; } var angleEnd = angleStart + angleSweep; //angleSweep = 360; var finalRadius = 503 / 2 - 24 / 2; // outer radius of blue blob (-width of blob) var outerRadius = 456 / 2; // outer radius of glow var innerRadius = outerRadius - 30; // inner radius of glow var endRadius = 296 / 2; // radius of inner part innerRadius = 1; var dialX = 700; var dialY = 284; GraphicsPath path = new GraphicsPath(); Point centerPoint = new Point(dialX, dialY); path.AddLine(this.DistanceFromCenter(centerPoint, innerRadius, angleStart), this.DistanceFromCenter(centerPoint, outerRadius, angleStart)); path.AddArc(new RectangleF(centerPoint.X - (float)outerRadius, centerPoint.Y - (float)outerRadius, (float)outerRadius * 2, (float)outerRadius * 2), angleStart, angleSweep); path.AddLine(this.DistanceFromCenter(centerPoint, outerRadius, angleEnd), this.DistanceFromCenter(centerPoint, innerRadius, angleEnd)); path.AddArc(new RectangleF(centerPoint.X - (float)innerRadius, centerPoint.Y - (float)innerRadius, (float)innerRadius * 2, (float)innerRadius * 2), angleEnd, -angleSweep); Blend blend = new Blend(); // Create point and positions arrays float[] factArray = { 0.1f, 1.0f, 1.0f }; float[] posArray = { 0.0f, 0.225f, 1.0f }; // Set Factors and Positions properties of Blend blend.Factors = factArray; blend.Positions = posArray; PathGradientBrush pthGrBrush = new PathGradientBrush(path); pthGrBrush.Blend = blend; pthGrBrush.CenterColor = bIn; pthGrBrush.CenterPoint = centerPoint; Color[] colors = { bGlow, bGlow, bGlow, bGlow }; pthGrBrush.SurroundColors = colors; g.FillPath(pthGrBrush, path); var p = new Pen(bOut, 22.0f); g.DrawArc(p, centerPoint.X - finalRadius, centerPoint.Y - finalRadius, finalRadius * 2, finalRadius * 2, angleStart, angleSweep); g.DrawLine(new Pen(bOut, 5.0f), this.DistanceFromCenter(centerPoint, finalRadius + 11, angleEnd), DistanceFromCenter(centerPoint, endRadius, angleEnd)); }
protected override void OnPaint(PaintEventArgs e) { var g = e.Graphics; g.Clear(Color.White); using (var dataPointPath = new GraphicsPath()) using (var gridPen = new Pen(Color.FromArgb(20, Color.Black))) using (var dashPen = new Pen(MainColor) { DashStyle = DashStyle.Dash }) using (var borderPen = new Pen(MainColor)) using (var fillBrush = new SolidBrush(Color.FromArgb(35, MainColor))) using (var textBrush = new SolidBrush(MainColor)) { if (DataPoints.Count > 1) { var infoRect = new Rectangle(); var highlightRect = new RectangleF(); var infoString = string.Empty; dataPointPath.AddLine(Width + 10, Height + 10, Width + 10, Height + 10); var offset = 0; for (var i = DataPoints.Count - 1; i >= 1; i--) { if (DataPoints[i].Index % LineDensity == 0) g.DrawLine(gridPen, Width - offset, 0, Width - offset, Height); var scaledY = GetScaledPoint(DataPoints[i].Value); dataPointPath.AddLine(Width - offset, scaledY, Width - offset - PointDensity, GetScaledPoint(DataPoints[i - 1].Value)); if (HighlightPoint && new Rectangle(Width - offset - (PointDensity / 2), 0, PointDensity, Height).Contains(MouseLocation)) { g.DrawLine(gridPen, 0, scaledY, Width, scaledY); highlightRect = new RectangleF(Width - offset - 3, scaledY - 3, 6, 6); infoString = DataPoints[i].Value.ToString(CultureInfo.InvariantCulture); var infoStringSize = TextRenderer.MeasureText(infoString, Font); infoRect = new Rectangle { Height = infoStringSize.Height + 2, Width = infoStringSize.Width + 5 }; if (offset < infoStringSize.Width + 10) infoRect.X = Width - offset - infoStringSize.Width - 10; else infoRect.X = Width - offset + 5; if (scaledY > Height - infoStringSize.Height - 5) infoRect.Y = (int)scaledY - infoStringSize.Height - 5; else infoRect.Y = (int)scaledY + 5; } offset += PointDensity; } dataPointPath.AddLine(-10, Height + 10, -10, Height + 10); dataPointPath.CloseFigure(); g.SmoothingMode = SmoothingMode.AntiAlias; g.FillPath(fillBrush, dataPointPath); g.DrawPath(borderPen, dataPointPath); g.SmoothingMode = SmoothingMode.None; if (ShowAverage) { var average = GetScaledPoint(GetAverage()); g.DrawLine(dashPen, 0, average, Width, average); g.FillRectangle(fillBrush, 0, average, Width, Height - average); } if (HighlightPoint) { g.SmoothingMode = SmoothingMode.AntiAlias; g.FillEllipse(Brushes.White, highlightRect); g.DrawEllipse(borderPen, highlightRect); g.SmoothingMode = SmoothingMode.None; g.FillRectangle(Brushes.White, infoRect); g.DrawRectangle(borderPen, infoRect); g.DrawString(infoString, HighlightFont, textBrush, infoRect.X + 4, infoRect.Y + 1); } } g.DrawRectangle(borderPen, new Rectangle(0, 0, Width - 1, Height - 1)); } }
private static void drawHeader(Bitmap myBitmap, JToken myBundle) { bool isSXBanner = false; string bundleDisplayName = BundleInfos.getBundleDisplayName(myItem); string lastFolder = BundleInfos.getLastFolder(BundlePath); JToken displayStyle = myBundle["DisplayStyle"]; if (displayStyle != null) { if (Settings.Default.isChallengesTheme) { string[] colorParts = Settings.Default.challengesColors.Split(','); headerColor = Color.FromArgb(255, Int32.Parse(colorParts[0]), Int32.Parse(colorParts[1]), Int32.Parse(colorParts[2])); } else { headerColor = BundleInfos.getSecondaryColor(myBundle); } JToken customBackground = displayStyle["CustomBackground"]; JToken displayImage = displayStyle["DisplayImage"]; if (customBackground != null) { JToken assetPathName = customBackground["asset_path_name"]; if (assetPathName != null) { if (assetPathName.Value <string>().Contains("/Game/Athena/UI/Challenges/Art/MissionTileImages/") && !ThePak.CurrentUsedItem.Equals("QuestBundle_S10_SeasonX")) { isSXBanner = true; string textureFile = Path.GetFileName(assetPathName.Value <string>()).Substring(0, Path.GetFileName(assetPathName.Value <string>()).LastIndexOf('.')); Image challengeIcon = Resources.unknown512; string textureAsset = JohnWick.AssetToTexture2D(textureFile);; if (!string.IsNullOrEmpty(textureAsset)) { using (var bmpTemp = new Bitmap(textureAsset)) { challengeIcon = new Bitmap(bmpTemp); } } toDrawOn.FillRectangle(new SolidBrush(headerColor), new Rectangle(-1, -1, myBitmap.Width + 1, 257)); if (Settings.Default.isChallengesTheme && File.Exists(Settings.Default.challengesBannerFileName)) { Image banner = Image.FromFile(Settings.Default.challengesBannerFileName); var opacityImage = ImageUtilities.SetImageOpacity(banner, (float)Settings.Default.challengesOpacity / 1000); toDrawOn.DrawImage(ImageUtilities.ResizeImage(opacityImage, 1024, 256), 0, 0); } else { var opacityImage = ImageUtilities.SetImageOpacity(challengeIcon, (float)0.3); toDrawOn.DrawImage(opacityImage, new Point(0, 0)); } } } } if (!isSXBanner) { if (displayImage != null) { JToken assetPathName = displayImage["asset_path_name"]; if (assetPathName != null) { string textureFile = Path.GetFileName(assetPathName.Value <string>()).Substring(0, Path.GetFileName(assetPathName.Value <string>()).LastIndexOf('.')); Image challengeIcon = Resources.unknown512; string textureAsset = JohnWick.AssetToTexture2D(textureFile); if (!string.IsNullOrEmpty(textureAsset)) { using (var bmpTemp = new Bitmap(textureAsset)) { challengeIcon = new Bitmap(bmpTemp); } } toDrawOn.FillRectangle(new SolidBrush(headerColor), new Rectangle(-1, -1, myBitmap.Width + 1, 257)); if (Settings.Default.isChallengesTheme) { if (File.Exists(Settings.Default.challengesBannerFileName)) { Image banner = Image.FromFile(Settings.Default.challengesBannerFileName); var opacityImage = ImageUtilities.SetImageOpacity(banner, (float)Settings.Default.challengesOpacity / 1000); toDrawOn.DrawImage(ImageUtilities.ResizeImage(opacityImage, 1024, 256), 0, 0); } } toDrawOn.DrawImage(ImageUtilities.ResizeImage(challengeIcon, 256, 256), new Point(0, 0)); } } else { toDrawOn.FillRectangle(new SolidBrush(headerColor), new Rectangle(-1, -1, myBitmap.Width + 1, 257)); if (Settings.Default.isChallengesTheme) { if (File.Exists(Settings.Default.challengesBannerFileName)) { Image banner = Image.FromFile(Settings.Default.challengesBannerFileName); var opacityImage = ImageUtilities.SetImageOpacity(banner, (float)Settings.Default.challengesOpacity / 1000); toDrawOn.DrawImage(ImageUtilities.ResizeImage(opacityImage, 1024, 256), 0, 0); } } } } } else { if (Settings.Default.isChallengesTheme) { string[] colorParts = Settings.Default.challengesColors.Split(','); headerColor = Color.FromArgb(255, Int32.Parse(colorParts[0]), Int32.Parse(colorParts[1]), Int32.Parse(colorParts[2])); } else { headerColor = getRandomColor(); } toDrawOn.FillRectangle(new SolidBrush(headerColor), new Rectangle(-1, -1, myBitmap.Width + 1, 257)); if (Settings.Default.isChallengesTheme) { if (File.Exists(Settings.Default.challengesBannerFileName)) { Image banner = Image.FromFile(Settings.Default.challengesBannerFileName); var opacityImage = ImageUtilities.SetImageOpacity(banner, (float)Settings.Default.challengesOpacity / 1000); toDrawOn.DrawImage(ImageUtilities.ResizeImage(opacityImage, 1024, 256), 0, 0); } } } GraphicsPath gp = new GraphicsPath(); gp.StartFigure(); gp.AddLine(0, 256, myBitmap.Width, 256); gp.AddLine(myBitmap.Width, 256, myBitmap.Width, 241); gp.AddLine(myBitmap.Width, 241, myBitmap.Width / 2 + 25, 236); gp.AddLine(myBitmap.Width / 2 + 25, 236, myBitmap.Width / 2 + 35, 249); gp.AddLine(myBitmap.Width / 2 + 35, 249, 0, 241); gp.CloseFigure(); toDrawOn.FillPath(new SolidBrush(ControlPaint.Light(headerColor)), gp); GraphicsPath p = new GraphicsPath(); Pen myPen = new Pen(ControlPaint.Light(headerColor, (float)0.2), 3); myPen.LineJoin = LineJoin.Round; //needed to avoid spikes p.AddString( lastFolder, Settings.Default.IconLanguage == "Japanese" ? FontUtilities.pfc.Families[2] : FontUtilities.pfc.Families[1], (int)FontStyle.Regular, 30, new Point(isSXBanner || displayStyle == null ? 30 : 265, 70), FontUtilities.leftString ); toDrawOn.DrawPath(myPen, p); toDrawOn.FillPath(new SolidBrush(ControlPaint.Dark(headerColor, (float)0.05)), p); toDrawOn.DrawString(bundleDisplayName, new Font(Settings.Default.IconLanguage == "Japanese" ? FontUtilities.pfc.Families[2] : FontUtilities.pfc.Families[1], 40), new SolidBrush(Color.White), new Point(isSXBanner || displayStyle == null ? 25 : 260, 105)); toDrawOn.FillRectangle(new SolidBrush(ControlPaint.Dark(headerColor, (float)0.1)), new Rectangle(-1, 255, myBitmap.Width + 1, myBitmap.Height)); }
public static void DrawTab(Graphics g, Rectangle r, Corners corner, GradientType gradient, Color darkColor, Color lightColor, Color edgeColor, bool closed) { //dims Point[] points; GraphicsPath path; Region Region; LinearGradientBrush linearBrush; Brush brush = null; Pen pen; r.Inflate(- 1, - 1); //set brushes switch (gradient) { case GradientType.Flat: brush = new SolidBrush(darkColor); break; case GradientType.Linear: brush = new LinearGradientBrush(r, darkColor, lightColor, LinearGradientMode.Vertical); break; case GradientType.Bell: linearBrush = new LinearGradientBrush(r, darkColor, lightColor, LinearGradientMode.Vertical); linearBrush.SetSigmaBellShape((float) (0.17F), (float) (0.67F)); brush = linearBrush; break; } pen = new pen(edgeColor, 1); //generic points points = new Point[12] {new Point(r.Left, r.Bottom), new Point(r.Left, r.Bottom - bshift), new Point(r.Left, r.Top + bshift), new Point(r.Left, r.Top), new Point(r.Left + bshift, r.Top), new Point(r.Right - bshift, r.Top), new Point(r.Right, r.Top), new Point(r.Right, r.Top + bshift), new Point(r.Right, r.Bottom - bshift), new Point(r.Right, r.Bottom), new Point(r.Right - bshift, r.Bottom), new Point(r.Left + bshift, r.Bottom)}; path = new GraphicsPath(); switch (corner) { case Corners.LeftBottom: path.AddLine(points[3], points[1]); path.AddBezier(points[1], points[0], points[0], points[11]); path.AddLine(points[11], points[9]); path.AddLine(points[9], points[6]); path.AddLine(points[6], points[3]); Region = new Region(path); g.FillRegion(brush, Region); g.DrawLine(pen, points[3], points[1]); g.DrawBezier(pen, points[1], points[0], points[0], points[11]); g.DrawLine(pen, points[11], points[9]); g.DrawLine(pen, points[9], points[6]); if (closed) { g.DrawLine(pen, points[6], points[3]); } break; case Corners.LeftTop: path.AddLine(points[0], points[2]); path.AddBezier(points[2], points[3], points[3], points[4]); path.AddLine(points[4], points[6]); path.AddLine(points[6], points[9]); path.AddLine(points[9], points[0]); Region = new Region(path); g.FillRegion(brush, Region); g.DrawLine(pen, points[0], points[2]); g.DrawBezier(pen, points[2], points[3], points[3], points[4]); g.DrawLine(pen, points[4], points[6]); g.DrawLine(pen, points[6], points[9]); if (closed) { g.DrawLine(pen, points[9], points[0]); } break; case Corners.Bottom: path.AddLine(points[1], points[3]); path.AddBezier(points[1], points[0], points[0], points[11]); path.AddLine(points[11], points[10]); path.AddBezier(points[10], points[9], points[9], points[8]); path.AddLine(points[8], points[6]); path.AddLine(points[6], points[3]); Region = new Region(path); g.FillRegion(brush, Region); g.DrawLine(pen, points[1], points[3]); g.DrawBezier(pen, points[1], points[0], points[0], points[11]); g.DrawLine(pen, points[11], points[10]); g.DrawBezier(pen, points[10], points[9], points[9], points[8]); g.DrawLine(pen, points[8], points[6]); if (closed) { g.DrawLine(pen, points[6], points[3]); } break; case Corners.Top: path.AddLine(points[0], points[2]); path.AddBezier(points[2], points[3], points[3], points[4]); path.AddLine(points[4], points[5]); path.AddBezier(points[5], points[6], points[6], points[7]); path.AddLine(points[7], points[9]); path.AddLine(points[9], points[0]); Region = new Region(path); g.FillRegion(brush, Region); g.DrawLine(pen, points[0], points[2]); g.DrawBezier(pen, points[2], points[3], points[3], points[4]); g.DrawLine(pen, points[4], points[5]); g.DrawBezier(pen, points[5], points[6], points[6], points[7]); g.DrawLine(pen, points[7], points[9]); if (closed) { g.DrawLine(pen, points[9], points[0]); } break; case Corners.RightBottom: path.AddLine(points[3], points[0]); path.AddLine(points[0], points[10]); path.AddBezier(points[10], points[9], points[9], points[8]); path.AddLine(points[8], points[6]); path.AddLine(points[6], points[3]); Region = new Region(path); g.FillRegion(brush, Region); g.DrawLine(pen, points[3], points[0]); g.DrawLine(pen, points[0], points[10]); g.DrawBezier(pen, points[10], points[9], points[9], points[8]); g.DrawLine(pen, points[8], points[6]); if (closed) { g.DrawLine(pen, points[6], points[3]); } break; case Corners.RightTop: path.AddLine(points[0], points[3]); path.AddLine(points[3], points[5]); path.AddBezier(points[5], points[6], points[6], points[7]); path.AddLine(points[7], points[9]); path.AddLine(points[9], points[0]); Region = new Region(path); g.FillRegion(brush, Region); g.DrawLine(pen, points[0], points[3]); g.DrawLine(pen, points[3], points[5]); g.DrawBezier(pen, points[5], points[6], points[6], points[7]); g.DrawLine(pen, points[7], points[9]); if (closed) { g.DrawLine(pen, points[9], points[0]); } break; } }
/// <summary> /// Supporting rounded corners. /// </summary> /// <param name="s"></param> /// <returns></returns> protected override RequestedAction PreRenderImage(ImageState s) { if (s.sourceBitmap == null) { return(RequestedAction.None); } double[] vals = s.settings.GetList <double>("s.roundcorners", 0, 1, 4); if (vals == null) { return(RequestedAction.None); } if (vals.Length == 1) { vals = new double[] { vals[0], vals[0], vals[0], vals[0] } } ; bool hasValue = false; foreach (double d in vals) { if (d > 0) { hasValue = true; } } if (!hasValue) { return(RequestedAction.None); } Bitmap cropped = null; try{ //Make sure cropping is applied, and use existing prerendered bitmap if present. s.ApplyCropping(); cropped = s.preRenderBitmap ?? s.sourceBitmap; s.preRenderBitmap = new Bitmap(cropped.Width, cropped.Height, PixelFormat.Format32bppArgb); int[] radius = new int[4]; //Radius percentages are 0-100, a percentage of the smaller of the width and height. for (int i = 0; i < vals.Length; i++) { radius[i] = (int)Math.Round(Math.Max(0, Math.Min(99.999, vals[i])) * ((double)Math.Min(s.preRenderBitmap.Width, s.preRenderBitmap.Height) / 100)); } s.preRenderBitmap.MakeTransparent(); using (Graphics g = Graphics.FromImage(s.preRenderBitmap)) { g.SmoothingMode = SmoothingMode.AntiAlias; g.CompositingMode = CompositingMode.SourceOver; g.CompositingQuality = CompositingQuality.HighQuality; g.PixelOffsetMode = PixelOffsetMode.HighQuality; using (TextureBrush tb = new TextureBrush(cropped)) using (GraphicsPath gp = new GraphicsPath(FillMode.Winding)) { Rectangle bounds = new Rectangle(0, 0, s.preRenderBitmap.Width, s.preRenderBitmap.Height); int[] angles = new int[] { 180, 270, 0, 90 }; int[] xs = new int[] { bounds.X, bounds.Right - radius[1], bounds.Right - radius[2], bounds.X }; int[] ys = new int[] { bounds.Y, bounds.Y, bounds.Bottom - radius[2], bounds.Bottom - radius[3] }; for (int i = 0; i < 4; i++) { if (radius[i] > 0) { gp.AddArc(xs[i], ys[i], radius[i], radius[i], angles[i], 90); } else { gp.AddLine(xs[i], ys[i], xs[i], ys[i]); } } g.FillPath(tb, gp); } } }finally{ if (cropped != null & cropped != s.sourceBitmap) { cropped.Dispose(); } } return(RequestedAction.None); }
private GraphicsPath DrawArrow(int x, int y, bool flip) { GraphicsPath GP = new GraphicsPath(); int W = 5; int H = 9; if (flip) { GP.AddLine(x, y + 1, x, y + H + 1); GP.AddLine(x, y + H, x + W - 1, y + W); } else { GP.AddLine(x + W, y, x + W, y + H); GP.AddLine(x + W, y + H, x + 1, y + W); } GP.CloseFigure(); return GP; }
public void picDrawingSurface_MouseMove(object sender, MouseEventArgs e) { label1.Text = e.X.ToString() + "X,Y" + e.Y.ToString(); x2 = e.X; y2 = e.Y; switch (selectedTool) { case "Circle": if (drawing) { Graphics g = Graphics.FromImage(picDrawingSurface.Image); g.Clear(Color.White); g.DrawEllipse(currentPen, x1, y1, x2 - x1, y2 - y1); g.FillEllipse(currentBrush, x1, y1, x2 - x1, y2 - y1); g.Dispose(); picDrawingSurface.Invalidate(); } break; case "Rectanglee": if (drawing) { //Graphics g = this.CreateGraphics(); Graphics g = Graphics.FromImage(picDrawingSurface.Image); g.Clear(Color.White); Point p = new Point(x1, y1); Size s = new Size(x2, y2); //g.DrawRectangle(currentBrush, x1, y1, x2 - x1, y2 - y1); Rectangle r2 = new Rectangle(p, s); g.DrawRectangle(currentPen, r2); //g.DrawRectangle(currentPen, x1, y1, x2 - x1, y2 - y1); g.FillRectangle(currentBrush, r2); g.Dispose(); picDrawingSurface.Invalidate(); } break; case "Pencil": if (drawing) { Graphics g = Graphics.FromImage(picDrawingSurface.Image); currentPath.AddLine(oldLocation, e.Location); //GraphicsPath currentPath; g.DrawPath(currentPen, currentPath); oldLocation = e.Location; g.Dispose(); picDrawingSurface.Invalidate(); } break; case "Line": if (drawing) { //twopoint.Clear(); Graphics g = Graphics.FromImage(picDrawingSurface.Image); g.Clear(Color.White); g.DrawLine(currentPen, new Point(x1, y1), new Point(x2, y2)); //g.Dispose(); picDrawingSurface.Invalidate(); foreach (var p in twopoint) { g.DrawLine(currentPen, p.X1, p.Y1); } } break; case "Polygon": if (drawing) { Graphics g = Graphics.FromImage(picDrawingSurface.Image); g.Clear(Color.White); Point[] pnts = new Point[points.Count]; for (int i = 0; i < points.Count; i++) { pnts[i] = points[i]; } g.DrawPolygon(currentPen, pnts); g.FillPolygon(currentBrush, pnts); g.SmoothingMode = SmoothingMode.HighQuality; g.Dispose(); picDrawingSurface.Invalidate(); } break; case "Polline": if (drawing) { Graphics g = Graphics.FromImage(picDrawingSurface.Image); g.Clear(Color.White); Point[] pnts = new Point[points.Count]; for (int i = 0; i < points.Count; i++) { pnts[i] = points[i]; } g.DrawLines(currentPen, pnts); //g.FillPolygon(currentBrush, pnts); g.SmoothingMode = SmoothingMode.HighQuality; g.Dispose(); picDrawingSurface.Invalidate(); } break; default: break; } //if (drawing) //{ // x2 = e.X; // y2 = e.Y; // Graphics g = Graphics.FromImage(picDrawingSurface.Image); // g.Clear(Color.White); // //g.DrawRectangle(currentBrush, x1, y1, x2 - x1, y2 - y1); // g.DrawRectangle(currentPen, x1, y1, x2 - x1, y2 - y1); // g.FillRectangle(currentBrush, x1, y1, x2 - x1, y2 - y1); // g.Dispose(); // picDrawingSurface.Invalidate(); // //Graphics g = Graphics.FromImage(picDrawingSurface.Image); // //currentPath.AddLine(oldLocation, e.Location);//GraphicsPath currentPath; // //g.DrawPath(currentPen, currentPath); // //oldLocation = e.Location; // //g.Dispose(); // //picDrawingSurface.Invalidate(); //} }