C# 圖形 DrawLine 刪除

Question

我的圖紙在我寫的代碼中被刪除了。 如果不使用“刷新”，則不會出現繪圖。 我的畫有錯誤嗎？ 我不明白如何在不擦除線條的情況下繪制新線條？

這是代碼

Pen pen;
        Point startXY;
        Point endXY;
        bool ismoving = false;
        
        string choice = "Line";
        public Form1(){
            InitializeComponent();}
        private void drawArea_MouseDown(object sender, MouseEventArgs e){
            startXY = e.Location;
            ismoving = true;}
        private void drawArea_MouseMove(object sender, MouseEventArgs e){
            if (ismoving == true){
                endXY = e.Location;
                drawArea.Refresh();}}
        private void drawArea_MouseUp(object sender, MouseEventArgs e){
            endXY = e.Location;
            ismoving = false;}
        private void Form1_Load(object sender, EventArgs e){
            //Graphics graph = drawArea.CreateGraphics();
            //graph.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.AntiAlias;
            pen = new Pen(Color.White,1);
            pen.StartCap = pen.EndCap = System.Drawing.Drawing2D.LineCap.Round;}
        private void drawArea_Paint(object sender, PaintEventArgs e){
            switch (choice){
                case "Line":{
                        e.Graphics.DrawLine(pen, startXY, endXY);
                        break;}}}

Answer 1

您的代碼需要知道如何隨時重新創建整個圖形 window，因為 windows 可能隨時要求它重新繪制。

所以你需要在一個列表中跟蹤要繪制的東西，並在Paint事件中使用這個列表來渲染到屏幕上。

下面是執行此操作的示例代碼。 結果看起來像這樣

public enum Tool
{
    Line,
    PolyLine,
    Circle,
}
public partial class Form1 : Form
{
    Point startXY;
    Point endXY;
    bool isMoving;
    Tool next;

    public Form1()
    {
        InitializeComponent();

        this.Drawing = new List<IDrawObject>();
        this.isMoving = false;
        this.next = Tool.Line;
        this.drawArea.BackColor = Color.Black;
        this.drawArea.BorderStyle = BorderStyle.FixedSingle;
    }

    public List<IDrawObject> Drawing { get; }

    protected override void OnLoad(EventArgs e)
    {
        base.OnLoad(e);

        drawArea.Resize += (s, ev) => drawArea.Refresh();
        drawArea.Paint += pictureBox1_Paint;
        drawArea.MouseDown += PictureBox1_MouseDown;
        drawArea.MouseMove += PictureBox1_MouseMove;
        drawArea.MouseUp += PictureBox1_MouseUp;
        this.KeyDown += (s, ev) =>
        {
            switch (ev.KeyCode)
            {
                case Keys.Space:
                    next = NextTool(next);
                    UpdateFormTitle();
                    break;
            }
        };

        UpdateFormTitle();
    }

    public void UpdateFormTitle()
    {
        this.Text = $"Draw Area. Tool={next}. Press [SPACE] to switch.";
    }

    private void PictureBox1_MouseUp(object sender, MouseEventArgs e)
    {
        isMoving = false;
        endXY = e.Location;

        Drawing.Add(NextDrawObject());
        drawArea.Invalidate();
    }

    private void PictureBox1_MouseMove(object sender, MouseEventArgs e)
    {
        if (isMoving)
        {
            endXY = e.Location;
            drawArea.Invalidate();
        }
    }

    private void PictureBox1_MouseDown(object sender, MouseEventArgs e)
    {
        isMoving = true;
        startXY = e.Location;
    }

    protected void pictureBox1_Paint(object sender, PaintEventArgs e)
    {
        e.Graphics.SmoothingMode = SmoothingMode.AntiAlias;
        using (var pen = new Pen(Color.White, 1))
        {
            pen.EndCap = LineCap.Round;
            pen.StartCap = LineCap.Round;
            foreach (var item in Drawing)
            {
                item.Draw(e.Graphics, pen);
            }

            if (isMoving)
            {
                pen.Color = Color.SteelBlue;
                pen.DashStyle = DashStyle.Dash;
                NextDrawObject().Draw(e.Graphics, pen);
            }
        }
    }

    public static float Distance(Point from, Point to)
    {
        var dx = (float)(to.X-from.X);
        var dy = (float)(to.Y-from.Y);
        return (float)Math.Sqrt(dx*dx+dy*dy);
    }

    public Tool NextTool(Tool current)
    {
        switch (current)
        {
            case Tool.Line:
                return Tool.Circle;
            case Tool.Circle:
                return Tool.Line;
            case Tool.PolyLine:
                throw new NotImplementedException();
            default:
                throw new NotSupportedException();
        }
    }

    public IDrawObject NextDrawObject()
    {
        switch (next)
        {
            case Tool.Line:
                return new Line(startXY, endXY);
            case Tool.PolyLine:
                throw new NotImplementedException();
            case Tool.Circle:
                var radius = Distance(startXY, endXY);
                return new Circle(startXY, radius);
            default:
                throw new NotSupportedException();
        }
    }
}

public interface IDrawObject
{
    void Draw(Graphics g, Pen pen);
}

public struct Line : IDrawObject
{
    public Line(PointF from, PointF to)
    {
        this.From=from;
        this.To=to;
    }

    public PointF From { get; }
    public PointF To { get; }

    public void Draw(Graphics g, Pen pen)
    {
        g.DrawLine(pen, From, To);
    }
}

public struct PolyLine : IDrawObject
{
    public PolyLine(params PointF[] nodes)
    {
        this.Nodes=nodes;
    }

    public PointF[] Nodes { get; }        

    public void Draw(Graphics g, Pen pen)
    {
        g.DrawLines(pen, Nodes);
    }
}

public struct Circle : IDrawObject
{
    public Circle(PointF center, float radius)
    {
        this.Center=center;
        this.Radius=radius;
    }

    public PointF Center { get; }
    public float Radius { get; }

    public void Draw(Graphics g, Pen pen)
    {
        g.DrawEllipse(pen, Center.X-Radius, Center.Y-Radius, 2*Radius, 2*Radius);
    }

}