private void CreateObjects() { brSolid = new SolidBrushPlus(Color.CornflowerBlue); penSolid = new PenPlus(Color.Red, 10); penSolid.SetEndCap(LineCap.LineCapRound); penSolid.SetStartCap(LineCap.LineCapArrowAnchor); brHatch = new HatchBrush(HatchStyle.HatchStyle25Percent, Color.Black, Color.White); penHatch = new PenPlus(brHatch, 10); penSolidTrans = new PenPlus(Color.FromArgb(-0x5f7f7f7f), 10); penSolidCustomCap = new PenPlus(Color.Black, 20); GraphicsPath path = new GraphicsPath(FillMode.FillModeAlternate); path.AddEllipse(-0.5f, -1.5f, 1, 3); CustomLineCap cap = new CustomLineCap(null, path, LineCap.LineCapFlat, 0); penSolidCustomCap.SetCustomEndCap(cap); penDash = new PenPlus(Color.Black, 5); penDash.SetDashStyle(DashStyle.DashStyleDot); brGrad = new LinearGradientBrush( new GpPointF(0, 0), new GpPointF(100, 100), Color.Black, Color.White); penGradient = new PenPlus(brGrad, 30); }
public bool IsOutlineVisible(float x, float y, PenPlus pen, GraphicsPlus g) { bool ret; SetStatus(NativeMethods.GdipIsOutlineVisiblePathPoint(nativePath, x, y, pen.nativePen, g.nativeGraphics, out ret)); return(ret); }
public GpStatus Widen( PenPlus pen, Matrix matrix, float flatness ) { GpMatrix nativeMatrix = new GpMatrix(); if (matrix != null) { nativeMatrix = matrix.nativeMatrix; } return(SetStatus(NativeMethods.GdipWidenPath( nativePath, pen.nativePen, nativeMatrix, flatness ))); }
private void drawRotatedArrow(GraphicsPlus graphics) { Debug.WriteLine("drawRotatedArrow: " + this.rotationAngle, this.ToString()); Point center = new Point(this.Width / 2, this.Height / 2); int arWidthHalf = ARROW_WIDTH / 2; //int arHeightHalf = ARROW_HEIGHT / 2; Point[] arrowPoints = { new Point(center.X, center.Y - arWidthHalf), new Point(center.X - 2*arWidthHalf/3, center.Y + arWidthHalf), new Point(center.X + 2*arWidthHalf/3, center.Y + arWidthHalf), new Point(center.X, center.Y + arWidthHalf/2) }; Debug.WriteLine("drawRotatedArrow: points " + PointUtil.pointsStr(arrowPoints), this.ToString()); PointMath.RotatePoints(arrowPoints, center, this.rotationAngle); Debug.WriteLine("drawRotatedArrow: points " + PointUtil.pointsStr(arrowPoints), this.ToString()); graphics.SetSmoothingMode(SmoothingMode.SmoothingModeAntiAlias); PenPlus pen = new PenPlus(ARROW_COLOR, 3); pen.SetEndCap(LineCap.LineCapRound); pen.SetStartCap(LineCap.LineCapRound); graphics.DrawLine(pen, new GpPoint(arrowPoints[0].X, arrowPoints[0].Y), new GpPoint(arrowPoints[1].X, arrowPoints[1].Y)); graphics.DrawLine(pen, new GpPoint(arrowPoints[1].X, arrowPoints[1].Y), new GpPoint(arrowPoints[3].X, arrowPoints[3].Y)); graphics.DrawLine(pen, new GpPoint(arrowPoints[3].X, arrowPoints[3].Y), new GpPoint(arrowPoints[2].X, arrowPoints[2].Y)); graphics.DrawLine(pen, new GpPoint(arrowPoints[2].X, arrowPoints[2].Y), new GpPoint(arrowPoints[0].X, arrowPoints[0].Y)); pen.Dispose(); }
public GpStatus DrawEllipse(PenPlus pen, int x, int y, int width, int height) { return SetStatus(NativeMethods.GdipDrawEllipseI(nativeGraphics, pen.nativePen, x, y, width, height)); }
public GpStatus DrawCurve(PenPlus pen, GpPoint[] points, int offset, int numberOfSegments, float tension) { return SetStatus(NativeMethods.GdipDrawCurve3I(nativeGraphics, pen.nativePen, points, points.Length, offset, numberOfSegments, tension)); }
public GpStatus DrawCurve(PenPlus pen, GpPointF[] points) { return SetStatus(NativeMethods.GdipDrawCurve(nativeGraphics, pen.nativePen, points, points.Length)); }
public GpStatus DrawBezier(PenPlus pen, int x1, int y1, int x2, int y2, int x3, int y3, int x4, int y4) { return SetStatus(NativeMethods.GdipDrawBezierI(nativeGraphics, pen.nativePen, x1, y1, x2, y2, x3, y3, x4, y4)); }
public bool IsOutlineVisible(GpPoint point, PenPlus pen, GraphicsPlus g) { return IsOutlineVisible(point.X, point.Y, pen, g); }
public bool IsOutlineVisible(float x, float y, PenPlus pen, GraphicsPlus g) { bool ret; SetStatus(NativeMethods.GdipIsOutlineVisiblePathPoint(nativePath, x, y, pen.nativePen, g.nativeGraphics, out ret)); return ret; }
public GpStatus Widen( PenPlus pen, Matrix matrix, float flatness ) { GpMatrix nativeMatrix = new GpMatrix(); if (matrix != null) nativeMatrix = matrix.nativeMatrix; return SetStatus(NativeMethods.GdipWidenPath( nativePath, pen.nativePen, nativeMatrix, flatness )); }
/// <summary> /// Initializes a new instance of <c>PieSlice</c> class with given /// bounds and visual style. /// </summary> /// <param name="xBoundingRect"> /// x-coordinate of the upper-left corner of the rectangle that is /// used to draw the top surface of the pie slice. /// </param> /// <param name="yBoundingRect"> /// y-coordinate of the upper-left corner of the rectangle that is /// used to draw the top surface of the pie slice. /// </param> /// <param name="widthBoundingRect"> /// Width of the rectangle that is used to draw the top surface of /// the pie slice. /// </param> /// <param name="heightBoundingRect"> /// Height of the rectangle that is used to draw the top surface of /// the pie slice. /// </param> /// <param name="sliceHeight"> /// Height of the pie slice. /// </param> /// <param name="startAngle"> /// Starting angle (in degrees) of the pie slice. /// </param> /// <param name="sweepAngle"> /// Sweep angle (in degrees) of the pie slice. /// </param> /// <param name="surfaceColor"> /// Color used to paint the pie slice. /// </param> /// <param name="shadowStyle"> /// Shadow style used for slice rendering. /// </param> /// <param name="edgeColorType"> /// Edge color style used for slice rendering. /// </param> public PieSlice(float xBoundingRect, float yBoundingRect, float widthBoundingRect, float heightBoundingRect, float sliceHeight, float startAngle, float sweepAngle, Color surfaceColor, ShadowStyle shadowStyle, EdgeColorType edgeColorType) : this() { // set some persistent values m_actualStartAngle = startAngle; m_actualSweepAngle = sweepAngle; m_surfaceColor = surfaceColor; m_shadowStyle = shadowStyle; m_edgeColorType = edgeColorType; // create pens for rendering Color edgeLineColor = EdgeColor.GetRenderingColor(edgeColorType, surfaceColor); m_pen = new PenPlus(edgeLineColor,3); //m_pen.SetLineJoin(LineJoin.LineJoinRound); //LineJoin = LineJoin.Round; InitializePieSlice(xBoundingRect, yBoundingRect, widthBoundingRect, heightBoundingRect, sliceHeight); }
/// <summary> /// Draws the outer periphery of the pie slice. /// </summary> /// <param name="graphics"> /// <c>Graphics</c> object used to draw the surface. /// </param> /// <param name="pen"> /// <c>Pen</c> used to draw outline. /// </param> /// <param name="brush"> /// <c>Brush</c> used to fill the quadrilateral. /// </param> /// <param name="boundingRect"> /// Bounding rectangle that is used to draw the top surface of the /// pie slice. /// </param> /// <param name="startAngle"> /// Start angle (in degrees) of the periphery section. /// </param> /// <param name="endAngle"> /// End angle (in degrees) of the periphery section. /// </param> /// <param name="pointStart"> /// Point representing the start of the periphery. /// </param> /// <param name="pointEnd"> /// Point representing the end of the periphery. /// </param> protected void DrawCylinderSurfaceSection(GraphicsPlus graphics, PenPlus pen, BrushPlus brush, float startAngle, float endAngle, GpPointF pointStart, GpPointF pointEnd) { GraphicsPath path = CreatePathForCylinderSurfaceSection(startAngle, endAngle, pointStart, pointEnd); graphics.FillPath(brush, path); graphics.DrawPath(pen, path); }
private void TestGdiPlus(GraphicsPlus graphics) { graphics.DrawImage(bmp, 0, 0, ClientRectangle.Width, ClientRectangle.Height); PenPlus pen; graphics.SetSmoothingMode(SmoothingMode.SmoothingModeAntiAlias); pen= new PenPlus(Color.Black, 15); pen.SetEndCap(LineCap.LineCapRound); pen.SetStartCap(LineCap.LineCapRound); pen.SetWidth(3); pen.SetColor(Color.FromArgb(0x7f7f7f7f)); pen.SetWidth(40); graphics.DrawLine(pen, 20, 20, ClientRectangle.Right - 20, ClientRectangle.Bottom - 20); graphics.DrawLine(pen, ClientRectangle.Right - 20, 20, 20, ClientRectangle.Bottom - 20); SmoothingMode mode = graphics.GetSmoothingMode(); graphics.SetSmoothingMode(SmoothingMode.SmoothingModeAntiAlias); foreach(GraphicsPath p in allPaths) graphics.DrawPath(penWrite, p); graphics.SetSmoothingMode(mode); pen.Dispose(); }
private void MainForm_Load(object sender, EventArgs e) { GpStatusPlus stat = NativeMethods.GdiplusStartup(out token, input, out output); string bitmapPath = System.IO.Path.GetDirectoryName(GetType().Assembly.GetModules()[0].FullyQualifiedName); bitmapPath = System.IO.Path.Combine(bitmapPath, "test.jpg"); StreamOnFile sf = new StreamOnFile(bitmapPath); bmp = new BitmapPlus(sf); penWrite = new PenPlus(Color.Blue, 3); path = new GraphicsPath(FillMode.FillModeAlternate); }
public GpStatus DrawArc(PenPlus pen, int x, int y, int width, int height, float startAngle, float sweepAngle) { return SetStatus(NativeMethods.GdipDrawArcI(nativeGraphics, pen.nativePen, x, y, width, height, startAngle, sweepAngle)); }
public GpStatus DrawArc(PenPlus pen, GpRect rect, float startAngle, float sweepAngle) { return DrawArc(pen, rect.X, rect.Y, rect.Width, rect.Height, startAngle, sweepAngle); }
/// <summary> /// Draws the <c>Quadrilateral</c> with <c>Graphics</c> provided. /// </summary> /// <param name="graphics"> /// <c>Graphics</c> used to draw. /// </param> /// <param name="pen"> /// <c>Pen</c> used to draw outline. /// </param> /// <param name="brush"> /// <c>Brush</c> used to fill the inside. /// </param> public void Draw(GraphicsPlus graphics, PenPlus pen, BrushPlus brush) { graphics.FillPath(brush, m_path); graphics.DrawPath(pen, m_path); }
public GpStatus DrawBezier(PenPlus pen, GpPoint pt1, GpPoint pt2, GpPoint pt3, GpPoint pt4) { return DrawBezier(pen, pt1.X, pt1.Y, pt2.X, pt2.Y, pt3.X, pt3.Y, pt4.X, pt4.Y); }
public GpStatus DrawLine(PenPlus pen, GpPoint pt1, GpPoint pt2) { return DrawLine(pen, pt1.X, pt1.Y, pt2.X, pt2.Y); }
public GpStatus DrawCurve(PenPlus pen, GpPoint[] points, float tension) { return SetStatus(NativeMethods.GdipDrawCurve2I(nativeGraphics, pen.nativePen, points, points.Length, tension)); }
public GpStatus DrawPath(PenPlus pen, GraphicsPath path) { return SetStatus(NativeMethods.GdipDrawPath(nativeGraphics, pen != null ? pen.nativePen : null, path != null ? path.nativePath : null)); }
public GpStatus DrawEllipse(PenPlus pen, GpRect rect) { return DrawEllipse(pen, rect.X, rect.Y, rect.Width, rect.Height); }
public GpStatus DrawRectangle(PenPlus pen, GpRectF rect) { return DrawRectangle(pen, rect.X, rect.Y, rect.Width, rect.Height); }
//public PixelOffsetMode GetPixelOffsetMode() //{ // PixelOffsetMode pixelOffsetMode = PixelOffsetMode.PixelOffsetModeInvalid; // SetStatus(NativeMethods.GdipGetPixelOffsetMode(nativeGraphics, // out pixelOffsetMode)); // return pixelOffsetMode; //} //public GpStatus SetPixelOffsetMode(PixelOffsetMode pixelOffsetMode) //{ // return SetStatus(NativeMethods.GdipSetPixelOffsetMode(nativeGraphics, // pixelOffsetMode)); //} //public GpStatus SetPageUnit(Unit unit) //{ // return SetStatus(NativeMethods.GdipSetPageUnit(nativeGraphics, // unit)); //} //public Unit GetPageUnit() //{ // Unit unit; // SetStatus(NativeMethods.GdipGetPageUnit(nativeGraphics, out unit)); // return unit; //} //public float GetPageScale() //{ // float scale; // SetStatus(NativeMethods.GdipGetPageScale(nativeGraphics, out scale)); // return scale; //} //public float GetDpiX() //{ // float dpi; // SetStatus(NativeMethods.GdipGetDpiX(nativeGraphics, out dpi)); // return dpi; //} //public float GetDpiY() //{ // float dpi; // SetStatus(NativeMethods.GdipGetDpiY(nativeGraphics, out dpi)); // return dpi; //} public GpStatus DrawLine(PenPlus pen, float x1, float y1, float x2, float y2) { return SetStatus(NativeMethods.GdipDrawLine(nativeGraphics, pen.nativePen, x1, y1, x2, y2)); }
public GpStatus DrawRectangle(PenPlus pen, float x, float y, float width, float height) { return SetStatus(NativeMethods.GdipDrawRectangle(nativeGraphics, pen.nativePen, x, y, width, height)); }
public GpStatus DrawRectangles(PenPlus pen, GpRect[] rects) { return SetStatus(NativeMethods.GdipDrawRectanglesI(nativeGraphics, pen.nativePen, rects, rects.Length)); }
internal GpPen GetNativePen(PenPlus pen) { return pen.nativePen; }
public bool IsOutlineVisible(GpPoint point, PenPlus pen, GraphicsPlus g) { return(IsOutlineVisible(point.X, point.Y, pen, g)); }
private void drawDirectionLinePlus(GraphicsPlus graphics) { graphics.SetSmoothingMode(SmoothingMode.SmoothingModeAntiAlias); PenPlus pen = new PenPlus(TARGET_LINE_COLOR, 3); pen.SetEndCap(LineCap.LineCapRound); pen.SetStartCap(LineCap.LineCapRound); graphics.DrawLine(pen, this.Width / 2, this.Height / 2, targetPoint.X, targetPoint.Y); pen.Dispose(); }