C# Graphics.DrawLine方法代码示例

 public override void Draw(Graphics Canvas)
 {
     Pen pen = new Pen(Color.Black);
     Canvas.DrawLine(pen, pts[0].X, pts[0].Y, pts[1].X, pts[1].Y);
     Canvas.DrawLine(pen, pts[1].X, pts[1].Y, pts[2].X, pts[2].Y);
     Canvas.DrawLine(pen, pts[2].X, pts[2].Y, pts[3].X, pts[3].Y);
     Canvas.DrawLine(pen, pts[3].X, pts[3].Y, pts[0].X, pts[0].Y);
 }

 public override void Draw(Graphics gr)
 {
     if (Ready)
     {
         gr.DrawLine(Pens.Green, A, B);
         gr.DrawLine(Pens.Green, B, C);
         gr.DrawLine(Pens.Green, C, A);
     }
 }

	static void DrawTestString (Graphics g, GraphicsUnit unit)
	{
		g.PageUnit = unit;
		float left = 50;
		float top = 50;
		float height = 10;

		g.DrawLine (Pens.Black, left, top, left, top + height);
		g.DrawLine (Pens.Black, left, top + height, left + height, top + height);

		Font font = new Font ("Arial", height, unit);
		g.DrawString ("Xyz| unit: " + unit.ToString (), font, Brushes.Black, left, top);
	}

 public static void DrawRoundRect(Graphics G, Rectangle R, int Curve, Color C)
 {
     using (Pen P = new Pen(C))
     {
         G.DrawArc(P, R.X, R.Y, Curve, Curve, 180, 90);
         G.DrawLine(P, Convert.ToInt32(R.X + Curve / 2), R.Y, Convert.ToInt32(R.X + R.Width - Curve / 2), R.Y);
         G.DrawArc(P, R.X + R.Width - Curve, R.Y, Curve, Curve, 270, 90);
         G.DrawLine(P, R.X, Convert.ToInt32(R.Y + Curve / 2), R.X, Convert.ToInt32(R.Y + R.Height - Curve / 2));
         G.DrawLine(P, Convert.ToInt32(R.X + R.Width), Convert.ToInt32(R.Y + Curve / 2), Convert.ToInt32(R.X + R.Width), Convert.ToInt32(R.Y + R.Height - Curve / 2));
         G.DrawLine(P, Convert.ToInt32(R.X + Curve / 2), Convert.ToInt32(R.Y + R.Height), Convert.ToInt32(R.X + R.Width - Curve / 2), Convert.ToInt32(R.Y + R.Height));
         G.DrawArc(P, R.X, R.Y + R.Height - Curve, Curve, Curve, 90, 90);
         G.DrawArc(P, R.X + R.Width - Curve, R.Y + R.Height - Curve, Curve, Curve, 0, 90);
     }
 }

 public override void Draw(Graphics e)
 {
     Point one = new Point();
     Point two = new Point();
     one.X = (First.X + Second.X) / 2;
     one.Y = First.Y;
     two.X = First.X;
     two.Y = Second.Y;
     e.DrawLine(new Pen(Color.Black), one, two);
     two.X = Second.X;
     e.DrawLine(new Pen(Color.Black), one, two);
     one.X = First.X;
     one.Y = Second.Y;
     e.DrawLine(new Pen(Color.Black), one, two);
 }

            public static void DrawDocumentGridLines(Graphics graphics, Rectangle rectangle, int gridSpacing)
            {
                Pen LinePen = new Pen(DefaultGridLineColor);

                for (int OffsetX = 0; OffsetX < rectangle.Width; OffsetX += gridSpacing)
                {
                    graphics.DrawLine(LinePen, new Point(OffsetX, 0), new Point(OffsetX, rectangle.Height));
                }

                for (int OffsetY = 0; OffsetY < rectangle.Height; OffsetY += gridSpacing)
                {
                    graphics.DrawLine(LinePen, new Point(0, OffsetY), new Point(rectangle.Width, OffsetY));
                }

                LinePen.Dispose();
            }

    public void Draw(Graphics graphics, Size buffersize)
    {
        //store transform, (like opengl's glPushMatrix())
        Matrix mat1 = graphics.Transform;

        //transform into position
        graphics.TranslateTransform(m_position.X, m_position.Y);
        graphics.RotateTransform(m_angle/(float)Math.PI * 180.0f);

        try
        {
            //draw body
            graphics.DrawRectangle(new Pen(m_color), rect);

            //draw line in the "forward direction"
            graphics.DrawLine(new Pen(Color.Yellow), 1, 0, 1, 5);
        }
        catch(OverflowException exc)
        {
            //physics overflow :(
        }

        //restore transform
        graphics.Transform = mat1;
    }

 /// <summary>
 /// Malt eine Kante auf dem Bildschirm auf
 /// </summary>
 /// <param name="gr">Graphics-Objekt, auf dem gezeichnet wird</param>
 /// <param name="i">Startknoten-Index</param>
 /// <param name="j">Endknoten-Index</param>
 public void drawEdge(Graphics gr, int i, int j)
 {
     gr.DrawLine(Pens.Black,
                 this.points[i].x*SCALE_FACTOR,
                 this.points[i].y*SCALE_FACTOR,
                 this.points[j].x*SCALE_FACTOR,
                 this.points[j].y*SCALE_FACTOR);
 }

 public override void Draw(Graphics Canvas)
 {
     Pen pen = new Pen (Color.Black);
     for (int i = 0; i < numPoints; i++)
     {
         Canvas.DrawLine(pen,pts[i].X ,
                             pts[i].Y,
                             pts[(i+1) % numPoints].X,
                             pts[(i+1) % numPoints].Y);
     }
 }

 public override void drawLines(Point[] points, Graphics canvas)
 {
     Pen pen = new Pen(Color.Black);
     for (int i = 0; i < points.Length; i++)
     {
         canvas.DrawLine(pen, points[i].X,
                             points[i].Y,
                             points[(i + 1) % points.Length].X,
                             points[(i + 1) % points.Length].Y);
     }
 }

 private void drawLine(Graphics gfc, Bitmap img)
 {
     //选择画10条线,也可以增加，也可以不要线，只要随机杂点即可
     for (int i = 0; i < 10; i++)
     {
         int x1 = ran.Next(img.Width);
         int y1 = ran.Next(img.Height);
         int x2 = ran.Next(img.Width);
         int y2 = ran.Next(img.Height);
         gfc.DrawLine(new Pen(Color.Silver), x1, y1, x2, y2);      //注意画笔一定要浅颜色，否则验证码看不清楚
     }
 }

        public static void Run()
        {
            // ExStart:DrawingLines
            // The path to the documents directory.
            string dataDir = RunExamples.GetDataDir_DrawingAndFormattingImages() + "SolidLines_out.bmp";

            // Creates an instance of FileStream
            using (FileStream stream = new FileStream(dataDir, FileMode.Create))
            {
                // Create an instance of BmpOptions and set its various properties
                BmpOptions saveOptions = new BmpOptions();
                saveOptions.BitsPerPixel = 32;
                saveOptions.Source = new StreamSource(stream);

                // Create an instance of Image
                using (Image image = Image.Create(saveOptions, 100, 100))
                {
                    // Create and initialize an instance of Graphics class and Clear Graphics surface
                    Graphics graphic = new Graphics(image);
                    graphic.Clear(Color.Yellow);

                    // Draw two dotted diagonal lines by specifying the Pen object having blue color and co-ordinate Points
                    graphic.DrawLine(new Pen(Color.Blue), 9, 9, 90, 90);
                    graphic.DrawLine(new Pen(Color.Blue), 9, 90, 90, 9);

                    // Draw a four continuous line by specifying the Pen object having Solid Brush with red color and two point structures
                    graphic.DrawLine(new Pen(new SolidBrush(Color.Red)), new Point(9, 9), new Point(9, 90));
                    graphic.DrawLine(new Pen(new SolidBrush(Color.Aqua)), new Point(9, 90), new Point(90, 90));
                    graphic.DrawLine(new Pen(new SolidBrush(Color.Black)), new Point(90, 90), new Point(90, 9));
                    graphic.DrawLine(new Pen(new SolidBrush(Color.White)), new Point(90, 9), new Point(9, 9));
                    image.Save();
                }
            }
            // ExEnd:DrawingLines
        }

    public static void drawObject(Graphics g, ObjectRec curObject, bool isSelected, float curScale, ImageList objectSprites)
    {
        //don't render commands
        if (curObject.type >= 0xFF00)
          return;

        var dict = curObject.additionalData;
        var myFont = new Font(FontFamily.GenericSansSerif, 6.0f);
        int x = curObject.x, y = curObject.y;
        int addX = dict["addX"];
        int addY = dict["addY"];
        int fromFloor = dict["fromFloor"];

        /*if (curObject.type < objectSprites.Images.Count)
        {
        var p1 = new Point((int)(x * curScale) - 8, (int)(y * curScale) - 8);
        var p2 = new Point(p1.X + (int)(addX/2 * curScale) - 8,  p1.Y + (int)(addY/2 * curScale) - 8);
        g.DrawImage(objectSprites.Images[curObject.type], p1);
        if (fromFloor == 0)
        {
          g.DrawImage(objectSprites.Images[curObject.type],p2);
          g.DrawLine(new Pen(Brushes.Red), p1, p2);
        }
        }
        else*/
        {
        var p1 = new Point((int)(x * curScale) - 8, (int)(y * curScale) - 8);
        g.FillRectangle(Brushes.Black, new Rectangle(p1, new Size(16, 16)));
        g.DrawString(curObject.type.ToString("X3"), myFont, Brushes.White, p1);
        if (fromFloor == 0)
        {
          var p2 = new Point(p1.X + (int)(addX/2 * curScale) - 8, p1.Y + (int)(addY/2 * curScale) - 8);
          g.FillRectangle(Brushes.Green, new Rectangle(p2, new Size(16, 16)));
          g.DrawString(curObject.type.ToString("X3"), myFont, Brushes.White, p2);
          g.DrawLine(new Pen(Brushes.Red), p1, p2);
        }
        }
        if (isSelected)
        g.DrawRectangle(new Pen(Brushes.Red, 2.0f), new Rectangle((int)(x * curScale) - 8, (int)(y * curScale) - 8, 16, 16));
    }

    protected override void OnPaint(System.Windows.Forms.PaintEventArgs e)
    {
        G = e.Graphics;
        G.Clear(BackColor);

        GP1 = DrawArrow(4, 6, false);
        GP2 = DrawArrow(5, 7, false);

        G.FillPath(B1, GP2);
        G.FillPath(B2, GP1);

        GP3 = DrawArrow(4, Height - 11, true);
        GP4 = DrawArrow(5, Height - 10, true);

        G.FillPath(B1, GP4);
        G.FillPath(B2, GP3);

        if (ShowThumb)
        {
            G.FillRectangle(B1, Thumb);
            G.DrawRectangle(P1, Thumb);
            G.DrawRectangle(P2, Thumb.X + 1, Thumb.Y + 1, Thumb.Width - 2, Thumb.Height - 2);

            int Y = 0;
            int LY = Thumb.Y + (Thumb.Height / 2) - 3;

            for (int I = 0; I <= 2; I++)
            {
                Y = LY + (I * 3);

                G.DrawLine(P1, Thumb.X + 5, Y, Thumb.Right - 5, Y);
                G.DrawLine(P2, Thumb.X + 5, Y + 1, Thumb.Right - 5, Y + 1);
            }
        }

        G.DrawRectangle(P3, 0, 0, Width - 1, Height - 1);
        G.DrawRectangle(P4, 1, 1, Width - 3, Height - 3);
    }

                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);

//.........这里部分代码省略.........