C# GDI画图系列（二） 实现画图

已于 2023-08-09 11:04:09 修改
阅读量2.3k 收藏 15
点赞数
分类专栏： C# GDI高级应用 文章标签： c# gdi/gdi+
于 2021-10-20 18:02:59 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39448579/article/details/120870812
版权

效果图
在这里插入图片描述
已经实现了画矩形和画线条，还有撤销和重做功能。

Form1为上一篇新建的画布界面
在Form1中添加个menuStrip
在这里插入图片描述
在这里插入图片描述
添加一个窗体Form2，
把它的IsMdiContainer属性设置为true。
添加一个menuStrip控件
在这里插入图片描述

public partial class Form2 : Form
    {
        Form1 docForm;

        public Form2()
        {
            InitializeComponent();
            NewFile();
            Application.Idle += this.OnIdle;
        }

        /// <summary>
        /// 空闲事件时，随时更新重做和撤销的状态
        /// </summary>
        private void OnIdle(object sender, EventArgs e)
        {
            Form1 currActiveDocForm = this.ActiveMdiChild as Form1;
            if (currActiveDocForm != null)
            {
                currActiveDocForm.UpdateUI();
            }
        }
        public void NewFile()
        {
            docForm = new Form1();                    
            docForm.MdiParent = this;
            docForm.WindowState = FormWindowState.Maximized;
            docForm.Show();
        }

        private void 新建ToolStripMenuItem_Click(object sender, EventArgs e)
        {
            NewFile();
        }
    }

当前图像不想要的时候可以直接开始新建一个画图。
接下来开始为画图做准备，有点小复杂。

先添加好接口
命令接口 ICommod
数据库接口 Idatabase
画图方法接口 IMyDraw

 public interface ICommod
    {

    }

interface Idatabase
    {

    }

interface IMyDraw
    {
        /// <summary>
        /// 画矩形的方法
        /// </summary>
        /// <param name="rec"></param>
        /// <param name="_pen"></param>
        void DrawRectangle(Rectangle rec, Pen _pen);
        /// <summary>
        /// 画直线的方法
        /// </summary>
        /// <param name="postion"></param>
        /// <param name="_pen"></param>
        void DrawHorLine(PointF[] postion, Pen _pen);
    }

下一步，添加一个所有图像的父类 Images
用来存储图像的位置点和画图方法

 /// <summary>
    /// 图像的父类
    /// </summary>
    class Images
    {
        #region 图像点集合
        //线段
        private Dictionary<string, PointF[]> lines = new Dictionary<string, PointF[]>();
        public Dictionary<string, PointF[]> Lines
        {
            get
            {
                return lines;
            }

            set
            {
                lines = value;
            }
        }
        //矩形
        private Dictionary<string, Rectangle> rectangles = new Dictionary<string, Rectangle>();
        public Dictionary<string, Rectangle> Rectangles
        {
            get
            {
                return rectangles;
            }

            set
            {
                rectangles = value;
            }
        }
        #endregion

        public int Id
        {
            get
            {
                return _id;
            }

            set
            {
                _id = value;
            }
        }
        private int _id;

        public Pen _pen;

        /// <summary>
        /// 添加图像时，对应ID增加，确保精确识别每一个图像
        /// </summary>
        public Images()
        {
            _id++;
        }

        /// <summary>
        /// 开始画图
        /// </summary>
        /// <param name="gd"></param>
        public void Draw(IMyDraw gd)
        {
            if (Lines.Keys.Count > 0)
            {
                foreach (string id in lines.Keys)
                {
                    gd.DrawHorLine(lines[id], _pen);                    
                }
            }
            if (Rectangles.Keys.Count > 0)
            {
                foreach (string id in rectangles.Keys)
                {
                    gd.DrawRectangle(rectangles[id], _pen);                  
                }
            }
        }
    }

添加画图类 MyDraw实现IMyDraw接口

    class MyDraw : IMyDraw
    {       
        private Graphics _g = null;
        public Graphics graphics
        {
            get { return _g; }
            set { _g = value; }
        }
        private Pen _pen = new Pen(Color.Black);
        public Pen pen
        {
            get { return _pen; }
            set { _pen = value; }
        }
        private Brush _brush = new SolidBrush(Color.Red);
        public Brush brush
        {
            get { return _brush; }
            set { _brush = value; }
        }
        private Presenter _presenter = null;
        public Presenter presenter
        {
            get { return _presenter; }
        }

        /// <summary>
        /// 构造器
        /// </summary>
        /// <param name="presenter"></param>
        public MyDraw(Presenter presenter)
        {
            _presenter = presenter;
        }

        #region  画图的方法
        public void DrawRectangle(Rectangle _rec, Pen mypen)
        {
            //画四边框
            _g.DrawRectangle(mypen == null ? _pen : mypen, _rec);
        }
        public void DrawHorLine(PointF[] postion, Pen mypen)
        {
            //画线           
            _g.DrawLine(mypen == null ? _pen : mypen, postion[0], postion[1]);
        }
        #endregion
    }

添加存储数据的数据库类database实现Idatabase接口

class database : Idatabase
    {
        private Presenter _presenter = null;
        public database(Presenter _pre)
        {
            _presenter = _pre;
            Clear();
        }
        private List<Images> lsitUndoRedo = new List<Images>();
        private List<Images> lsit = new List<Images>();
        /// <summary>
        /// 图像集合
        /// </summary>
        public List<Images> Lsit
        {
            get
            {
                return lsit;
            }
        }
        /// <summary>
        /// 撤销图像集合
        /// </summary>
        internal List<Images> LsitUndoRedo
        {
            get
            {
                return lsitUndoRedo;
            }

            set
            {
                lsitUndoRedo = value;
            }
        }

        public void Addimage1(Images image)
        {
            lsitUndoRedo.Add(image);
        }
        public void Removeimage1(Images image)
        {
            lsitUndoRedo.Remove(image);
        }
        public void Removeimage1(int index)
        {
            lsitUndoRedo.RemoveAt(index);
        }
        public Images Lastimage1()
        {
            return lsitUndoRedo.Last();
        }
        public Images Firstimage1()
        {
            return lsitUndoRedo.First();
        }
        public Images Lastimage()
        {
            return lsit.Last();
        }
        public Images Firstimage()
        {
            return lsit.First();
        }
        public int index(Images image)
        {
            return lsit.FindIndex(t => t == image);
        }
        public bool contains(Images image)
        {
            return lsit.Contains(image);
        }
        public void SetImage(int _index, Images image)
        {
            lsit[_index] = image;
        }
        public void Addimage(Images image)
        {
            lsit.Add(image);
        }
        public void Removeimage(Images image)
        {
            lsit.Remove(image);
        }
        public void Removeimage(int index)
        {
            lsit.RemoveAt(index);
        }
        public void Clear()
        {
            lsit.Clear();
        }
    }

添加命令类CommodArgS和Commod

internal abstract class Commod : ICommod
    {   /// <summary>
        /// 命令管理器
        /// </summary>
        protected CommodArgS _mgr = null;
        internal CommodArgS cmdMgr
        {
            get { return _mgr; }
            set { _mgr = value; }
        }
        /// <summary>
        /// 初始化
        /// </summary>
        public virtual void Initialize()
        {

        }
        /// <summary>
        /// 结束
        /// </summary>
        public virtual void Terminate()
        {

        }
        /// <summary>
        /// 撤销
        /// </summary>
        public virtual void Undo()
        {

        }
        /// <summary>
        /// 重做
        /// </summary>
        public virtual void Redo()
        {

        }
        /// <summary>
        /// 完成
        /// </summary>
        public virtual void Finish()
        {

        }
        /// <summary>
        /// 取消
        /// </summary>
        public virtual void Cancel()
        {

        }
        /// <summary>
        /// Mouse Down
        /// </summary>
        public virtual EventResult OnMouseDown(MouseEventArgs e)
        {
            return EventResult.Unhandled;
        }

        /// <summary>
        /// Mouse Up
        /// </summary>
        public virtual EventResult OnMouseUp(MouseEventArgs e)
        {
            return EventResult.Unhandled;
        }

        /// <summary>
        /// Mouse Move
        /// </summary>
        public virtual EventResult OnMouseMove(MouseEventArgs e)
        {
            return EventResult.Unhandled;
        }

        /// <summary>
        /// Mouse Wheel
        /// </summary>
        public virtual EventResult OnMouseWheel(MouseEventArgs e)
        {
            return EventResult.Unhandled;
        }

        /// <summary>
        /// Key Down
        /// </summary>
        public virtual EventResult OnKeyDown(KeyEventArgs e)
        {
            return EventResult.Unhandled;
        }

        /// <summary>
        /// Key Up
        /// </summary>
        public virtual EventResult OnKeyUp(KeyEventArgs e)
        {
            return EventResult.Unhandled;
        }

        /// <summary>
        /// Paint
        /// </summary>
        public virtual void OnPaint(Graphics g)
        {

        }
        /// <summary>
        /// 事件处理结果
        /// </summary>
        public class EventResult
        {
            public EventResultStatus status = EventResultStatus.Invalid;
            public object data = null;

            /// <summary>
            /// 未处理事件
            /// </summary>
            public static EventResult Unhandled
            {
                get
                {
                    EventResult eRet = new EventResult();
                    eRet.status = EventResultStatus.Unhandled;
                    return eRet;
                }
            }

            /// <summary>
            /// 处理了事件
            /// </summary>
            public static EventResult Handled
            {
                get
                {
                    EventResult eRet = new EventResult();
                    eRet.status = EventResultStatus.Handled;
                    return eRet;
                }
            }
        }

        /// <summary>
        /// 事件结果状态
        /// </summary>
        public enum EventResultStatus
        {
            // 无效
            Invalid = 0,
            // 处理了
            Handled = 1,
            // 未处理
            Unhandled = 2,
        }
    }

/// <summary>
    /// 命令窗口
    /// </summary>
    class CommodArgS
    {
        /// <summary>
        /// 构造函数
        /// </summary>
        public CommodArgS(Presenter presenter)
        {
            _presenter = presenter;
        }
        /// <summary>
        /// Presenter
        /// </summary>
        private Presenter _presenter = null;
        public Presenter presenter
        {
            get { return _presenter; }
        }
        /// <summary>
        /// 当前命令
        /// </summary>
        private Commod _currentCmd = null;
        public Commod CurrentCmd
        {
            get { return _currentCmd; }
        }
        /// <summary>
        /// 命令完成事件
        /// </summary>
        public delegate void CommandEvent(Commod cmd);//定义事件的处理方法的方式：传入一个命令，返回值为void
        public event CommandEvent commandFinished;
        public event CommandEvent commandCanceled;
        /// <summary>
        /// 命令列表:撤销
        /// </summary>
        private List<Commod> _undoCmds = new List<Commod>();
        /// <summary>
        ///  命令列表:重做
        /// </summary>
        private List<Commod> _redoCmds = new List<Commod>();
        /// <summary>
        /// 判断是否可以撤销
        /// </summary>
        internal bool canUndo
        {
            get { return UndoCmds.Count > 0; }
        }
        /// <summary>
        /// 判断是否可以重做
        /// </summary>
        internal bool canRedo
        {
            get { return _redoCmds.Count > 0; }
        }
        internal List<Commod> UndoCmds
        {
            get
            {
                return _undoCmds;
            }

            set
            {
                _undoCmds = value;
            }
        }
        /// <summary>
        /// 设置当前的执行命令
        /// </summary>
        public void DoCommand(Commod cmd)
        {
            //如果当前命令不为空，说明命令没有执行完,就不再执行
            if (_currentCmd != null)
            {
                return;
            }
            _currentCmd = cmd;//设置当前执行的命令
            _currentCmd.cmdMgr = this;//命令的命令窗口是这里
            _currentCmd.Initialize();
        }
        /// <summary>
        /// 绘制
        /// </summary>
        public void OnPaint(Graphics g)
        {
            if (_currentCmd != null)
            {
                _currentCmd.OnPaint(g);
            }
        }

        /// <summary>
        /// Mouse Down
        /// </summary>
        public void OnMouseDown(MouseEventArgs e)
        {
            if (_currentCmd != null)
            {
                //调用每个画图命令的不同的按下方法，一般统一为按下记录按下的位置，弹起记录弹起的位置
                _currentCmd.OnMouseDown(e);
            }
        }

        /// <summary>
        /// Mouse Up
        /// </summary>
        public void OnMouseUp(MouseEventArgs e)
        {
            if (_currentCmd != null)
            {
                _currentCmd.OnMouseUp(e);
            }
        }

        /// <summary>
        /// Mouse Move
        /// </summary>
        public void OnMouseMove(MouseEventArgs e)
        {
            if (_currentCmd != null)
            {
                _currentCmd.OnMouseMove(e);
            }
        } /// <summary>
          /// 完成当前命令
          /// </summary>
        public void FinishCurrentCommand()
        {
            if (_currentCmd != null)
            {
                _currentCmd.Finish();
                if (_currentCmd is UndoCmd)
                {
                    this.Undo();
                }
                else if (_currentCmd is RedoCmd)
                {
                    this.Redo();
                }
                else
                {
                    UndoCmds.Add(_currentCmd);
                    _redoCmds.Clear();
                }
                commandFinished.Invoke(_currentCmd);
                _currentCmd = null;
            }
        }
        /// <summary>
        /// 撤销
        /// </summary>
        private void Undo()
        {
            if (UndoCmds.Count == 0)
            {
                return;
            }
            Commod cmd = UndoCmds[UndoCmds.Count - 1];
            UndoCmds.RemoveAt(UndoCmds.Count - 1);
            cmd.Undo();
            _redoCmds.Add(cmd);
        }

        /// <summary>
        /// 重做
        /// </summary>
        private void Redo()
        {
            if (_redoCmds.Count == 0)
            {
                return;
            }
            Commod cmd = _redoCmds[_redoCmds.Count - 1];
            _redoCmds.RemoveAt(_redoCmds.Count - 1);
            cmd.Redo();
            UndoCmds.Add(cmd);
        }
    }

添加撤销和重做的命令RedoCmd，UndoCmd

 /// <summary>
    /// 撤销命令
    /// </summary>
    class UndoCmd : Commod
    {
        public override void Initialize()
        {
            base.Initialize();

            _mgr.FinishCurrentCommand();
        }
    }

/// <summary>
    /// 重做命令
    /// </summary>
    class RedoCmd : Commod
    {
        public override void Initialize()
        {
            base.Initialize();

            _mgr.FinishCurrentCommand();
        }
    }

Presenter类代码添加

class Presenter : IParents
    {
        /// <summary>
        /// 画布
        /// </summary>
        private IMyCanvas _canvas = null;
        /// <summary>
        /// 鼠标标识
        /// </summary>
        private MousePoint _point = null;
        /// <summary>
        /// 存储当前界面的图像
        /// </summary>
        private Bitmap _bufferBitmap = null;
        private bool _bufferBitmapToRedraw = true;
        /// <summary>
        /// 命令管理器
        /// </summary>
        private CommodArgS _cmdsMgr = null;

        public MyDraw worldDraw
        {
            get { return _Draw; }
        }
        /// <summary>
        /// 所有画图的方法，图像内部直接调用。可以直接画图
        /// </summary>
        private MyDraw _Draw = null;
        /// <summary>
        /// 存储图元
        /// </summary>
        private database _db = null;
        public database Db
        {
            get
            {
                return _db;
            }
        }
        internal bool canUndo
        {
            get { return CmdsMgr.canUndo; }
        }
        internal bool canRedo
        {
            get { return CmdsMgr.canRedo; }
        }
        public IMyCanvas canvas
        {
            get
            {
                return _canvas;
            }
        }
        internal CommodArgS CmdsMgr
        {
            get
            {
                return _cmdsMgr;
            }

            set
            {
                _cmdsMgr = value;
            }
        }

        public Presenter(IMyCanvas canvas)
        {
            _canvas = canvas;
            //new一个画图的方法对象,传入主导对象目前未发现有何作用
            _Draw = new MyDraw(this);
            //命令窗口。新建
            CmdsMgr = new CommodArgS(this);
            //构造函数就定义好了鼠标的标识
            _point = new MousePoint(this);
            //所有数据的集合
            _db = new database(this);
            CmdsMgr.commandFinished += this.OnCommandFinished;
            CmdsMgr.commandCanceled += this.OnCommandCanceled;
        }

        /// <summary>
        /// 设置当前的执行命令
        /// </summary>
        public void OnCommand(ICommod cmd)
        {
            CmdsMgr.DoCommand(cmd as Commod);
        }
        /// <summary>
        /// 命令完成，对图像数据库进行处理
        /// </summary>
        public void OnCommandFinished(Commod cmd)
        {
            if (cmd is RedoCmd) //重做
            {
                _db.Addimage(_db.Lastimage1());
                _db.Removeimage1(_db.Lastimage1());
            }
            else if (cmd is UndoCmd)//撤销
            {
                _db.Addimage1(_db.Lastimage());
                _db.Removeimage(_db.Lastimage());
            }
            this.RepaintCanvas(true);
        }
        /// <summary>
        /// 命令取消
        /// </summary>
        public void OnCommandCanceled(Commod cmd)
        {
            this.RepaintCanvas(false);
        }

        /// <summary>
        /// 将图像存入数据集合
        /// </summary>
        /// <param name="_image"></param>
        public void SaveImage(Images _image)
        {
            if (!_db.contains(_image))
            {
                _db.Addimage(_image);
            }
        }

        public void DrawEntity(Graphics graphics, Images _image)
        {
            _Draw.graphics = graphics;
            _image.Draw(_Draw);

        }

        /// <summary>
        /// 鼠标在画布上按下时，调用主导的按下方法
        /// </summary>
        /// <param name="e"></param>
        public void OnMouseDown(MouseEventArgs e)
        {

            //如果当前有要执行的绘图命令              
            if (CmdsMgr.CurrentCmd != null)
            {
                //调用绘图的按下方法
                CmdsMgr.OnMouseDown(e);
                RepaintCanvas(true);
            }
        }
        /// <summary>
        /// 鼠标在画布上挪动时，触发主导的鼠标移动事件
        /// </summary>
        /// <param name="e"></param>
        public void OnMouseMove(MouseEventArgs e)
        {
            _point.OnMouseMove(e);
            if (CmdsMgr.CurrentCmd != null)
            {
                CmdsMgr.OnMouseMove(e);
                RepaintCanvas(true);
            }
        }
        public void OnMouseUp(MouseEventArgs e)
        {
            if (CmdsMgr.CurrentCmd != null)
            {
                CmdsMgr.OnMouseUp(e);
                RepaintCanvas();
            }
        }
        public void OnKeyDown(KeyEventArgs e)
        {

        }

        public void OnKeyUp(KeyEventArgs e)
        {

        }
        public void OnMouseDoubleClick(MouseEventArgs e)
        {

        }
        public void OnResize(EventArgs e)
        {
            RepaintCanvas(true);
        }
        public void OnMouseWheel(MouseEventArgs e)
        {

        }

        internal void RepaintCanvas(bool bufferBitmapToRedraw = false)
        {
            if (bufferBitmapToRedraw)
                _bufferBitmapToRedraw = true;//对图像进行了更改，需要进行刷新图像区域
            _canvas.Repaint();
        }
        /// <summary>
        /// 主要绘图的方法
        /// </summary>
        /// <param name="e"></param>
        public void OnPaintCanvas(PaintEventArgs e)
        {
            int canvasWidth = (int)_canvas.width;//获取画布宽
            int canvasHeight = (int)_canvas.height;//获取画布高
            Rectangle clipRectangle = e.ClipRectangle;
            Rectangle canvasRectangle = new Rectangle(0, 0, canvasWidth, canvasHeight);//画图的区域的大小
            if (_bufferBitmap == null)//当前界面的图像为空
            {
                clipRectangle = canvasRectangle;//绘画区域就是画布区域
                _bufferBitmap = new Bitmap(canvasWidth, canvasHeight);
                _bufferBitmapToRedraw = true;
            }
            if (_bufferBitmapToRedraw)
            {
                _bufferBitmapToRedraw = false;
                Graphics graphics = Graphics.FromImage(_bufferBitmap);//获取图像的画图对象
                graphics.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.AntiAlias;//设置绘画的质量。抗拒齿等
                // 绘制背景
                graphics.Clear(Color.FromArgb(255, 255, 255));//先清除所有的图像
                //draw的意义是，图像调用画图的方法，直接画图
                _Draw.graphics = graphics;//                
                foreach (Images _image in _db.Lsit) //所有的图形
                {
                    //图像调用画图的方法，直接画图         
                    _image.Draw(_Draw);
                }
            }
            // 双缓冲:将图片绘制到画布
            e.Graphics.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.AntiAlias;
            e.Graphics.InterpolationMode = System.Drawing.Drawing2D.InterpolationMode.NearestNeighbor;
            e.Graphics.PixelOffsetMode = System.Drawing.Drawing2D.PixelOffsetMode.Half;
            e.Graphics.DrawImage(_bufferBitmap, clipRectangle, clipRectangle, GraphicsUnit.Pixel);
            // 命令管理器绘制

            //随时绘制图像
            CmdsMgr.OnPaint(e.Graphics);
            //画出鼠标点
            _point.OnPaint(e.Graphics);
        }
    }

接下来可以准备画图了

添加画直线的命令HorLine

class HorLine : Commod
    {

        private Images _rectangle = null;

        /// <summary>
        /// 步骤
        /// </summary>
        private enum Step
        {
            Step1 = 1,
            Step2 = 2,
        }
        private Presenter _presenter = null;
        public HorLine(Presenter presenter)
        {
            _presenter = presenter;
        }
        private Step _step = Step.Step1;

        // 起点+终点
        private PointF _point1st = new PointF(0, 0);
        private PointF _point2nd = new PointF(0, 0);
        /// <summary>
        /// 初始化
        /// </summary>
        public override void Initialize()
        {
            base.Initialize();
            _step = Step.Step1;
        }
        public void UpdatePoint()
        {
            _rectangle = new Images();
            if (!_rectangle.Lines.ContainsKey(_rectangle.Id.ToString()))
            {
                _rectangle.Lines.Add(_rectangle.Id.ToString(), new PointF[] { _point1st, _point2nd });
            }
        }
        public override EventResult OnMouseDown(MouseEventArgs e)
        {
            switch (_step)
            {
                case Step.Step1:  //鼠标第一次按下时，记录点击的坐标位置
                    if (e.Button == MouseButtons.Left)
                    {
                        _step = Step.Step2;
                        _point1st = e.Location;
                    }
                    break;
                case Step.Step2:
                    if (e.Button == MouseButtons.Left)
                    {
                        //_point2nd = e.Location;
                        //this.UpdatePoint();
                        //_mgr.FinishCurrentCommand();
                    }
                    break;
            }
            return EventResult.Handled;
        }

        public override EventResult OnMouseUp(MouseEventArgs e)
        {
            if (_rectangle != null)
            {
                _rectangle._pen = new Pen(this._presenter.worldDraw.pen.Color, this._presenter.worldDraw.pen.Width);
                _presenter.SaveImage(_rectangle);//鼠标弹起，将图像保存到图像集合里
            }
            _mgr.FinishCurrentCommand();
            return EventResult.Handled;
        }
        public override EventResult OnMouseMove(MouseEventArgs e)
        {
            if (e.Button == MouseButtons.Middle)
            {
                return EventResult.Handled;
            }
            if (_step == Step.Step2)//第二步画图，
            {
                _point2nd = e.Location;//随时记录移动的位置
                this.UpdatePoint();
            }
            return EventResult.Handled;
        }
        public override void OnPaint(Graphics g)
        {
            //随时画出自己想画的图像
            if (_rectangle != null)
            {
                this._presenter.DrawEntity(g, _rectangle);
            }
        }
    }

画矩形的命令RectangleLine

 class RectangleLine : Commod
    {
        private Images _rectangle = null;

        /// <summary>
        /// 步骤
        /// </summary>
        private enum Step
        {
            Step1 = 1,
            Step2 = 2,
        }
        private Presenter _presenter = null;
        public RectangleLine(Presenter presenter)
        {
            _presenter = presenter;
        }
        private Step _step = Step.Step1;

        // 起点+终点
        private PointF _point1st = new PointF(0, 0);
        private PointF _point2nd = new PointF(0, 0);
        /// <summary>
        /// 初始化
        /// </summary>
        public override void Initialize()
        {
            base.Initialize();
            _step = Step.Step1;
        }
        public void UpdatePoint()
        {
            _rectangle = new Images();
            if (!_rectangle.Rectangles.ContainsKey(_rectangle.Id.ToString()))
                _rectangle.Rectangles.Add(_rectangle.Id.ToString(), new Rectangle(new Point((int)_point1st.X, (int)_point1st.Y), new Size((int)(_point2nd.X - _point1st.X), (int)(_point2nd.Y - _point1st.Y))));
        }
        public override EventResult OnMouseDown(MouseEventArgs e)
        {
            switch (_step)
            {
                case Step.Step1:
                    if (e.Button == MouseButtons.Left)
                    {
                        _step = Step.Step2;
                        _point1st = e.Location;
                    }
                    break;
                case Step.Step2:
                    if (e.Button == MouseButtons.Left)
                    {
                        //_point2nd = e.Location;
                        //this.UpdatePoint();
                        //_mgr.FinishCurrentCommand();
                    }
                    break;
            }
            return EventResult.Handled;
        }

        public override EventResult OnMouseUp(MouseEventArgs e)
        {
            if (_rectangle != null)
            {
                _rectangle._pen = new Pen(this._presenter.worldDraw.pen.Color, this._presenter.worldDraw.pen.Width);
                _presenter.SaveImage(_rectangle);
            }
            _mgr.FinishCurrentCommand();
            return EventResult.Handled;
        }
        public override EventResult OnMouseMove(MouseEventArgs e)
        {
            if (e.Button == MouseButtons.Middle)
            {
                return EventResult.Handled;
            }
            if (_step == Step.Step2)
            {
                _point2nd = e.Location;
                this.UpdatePoint();
            }

            return EventResult.Handled;
        }
        public override void OnPaint(Graphics g)
        {
            if (_rectangle != null)
            {
                this._presenter.DrawEntity(g, _rectangle);
            }
        }
    }

Form1 完整代码

 public partial class Form1 : Form
    {
        private Presenter _presenter = null;
        private CanavsControl _canvas = null;//画布

        public Form1()
        {
            InitializeComponent();
            _canvas = new CanavsControl();
            _presenter = new Presenter(_canvas);
            _canvas.Dock = DockStyle.Fill;
            _canvas.SetPresenter(_presenter);
            this.Controls.Add(_canvas);
        }

        /// <summary>
        /// 实时更新撤销和重做按钮的状态
        /// </summary>
        internal void UpdateUI()
        {
            撤销ToolStripMenuItem.Enabled = _presenter.canUndo;
            重做ToolStripMenuItem.Enabled = _presenter.canRedo;
        }
        private void 线条ToolStripMenuItem_Click(object sender, EventArgs e)
        {
            HorLine _hor = new HorLine(_presenter);
            _presenter.OnCommand(_hor);
        }

        private void 矩形ToolStripMenuItem_Click(object sender, EventArgs e)
        {
            RectangleLine _rec = new RectangleLine(_presenter);
            _presenter.OnCommand(_rec);
        }


        private void 撤销ToolStripMenuItem_Click(object sender, EventArgs e)
        {
            UndoCmd red = new UndoCmd();
            _presenter.OnCommand(red);
        }

        private void 重做ToolStripMenuItem_Click(object sender, EventArgs e)
        {
            RedoCmd red = new RedoCmd();
            _presenter.OnCommand(red);
        }
    }
yangzm996
关注
  • 0
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 6
    评论
专栏目录
C#的GDI画图
qq_29760029的博客
01-15 372
//在窗体重新绘制的时候，重新加载划线 private void Form1_Paint(object sender, PaintEventArgs e) { //创建GDI图像 Graphics graphics = this.CreateGraphics(); //创建画笔对象 ...
C# GDI+画图
aerkate的专栏
04-05 1452
绘制直线、矩形、曲线和多边形 绘制直线 public void DrawLine(Pen pen,Point,Point); public void DrawLine(Pen pen,PointF,PointF); public void DrawLine(Pen pen,int,int,int,int); public void DrawLine(Pen pen, float,
C#绘图程序(画图)
01-11
c#写的GDI+的应用小程序，实现了画圆，矩形等基本功能。可以实现线条粗细控制，颜色等。但只能画完图后，才可以看到所画图形。可以自行完善
基于GDI+的 图元绘制拾取 C#实现
03-26
基于GDI+的图元绘制拾取 C#实现 程序效果如博客http://blog.csdn.net/small_fish__/article/details/7394304所见
C#实现图形绘制
最新发布
m0_74066140的博客
06-14 699
渐变字的实现：在该代码中渐变字的实现思路是，graphics有DrawString的方法，相当于写了一串字，而实现是用LinearGradientBrush方法定义渐变brush，用这个来给字填充渐变色，实现效果，即定义了渐变brush，这个需要两种颜色和point渐变点。填充上色使用brush来实现，brush需要一般参数需要颜色color，同时存在不同的brush创建方式，需要的不同的参数，定义了brush，再可以用graphics的填充函数来对已有图形填充。
C# 绘图（1）
MechMaster
06-08 7020
绘图 1. 概述 2. 坐标系和颜色 3. Graphics类 4. 画笔和画刷 5. 路径 6. 重写OnPaint方法 7. 绘图示例代码 8. 代码下载地址
C# Winform GDI+ 绘图
熊思雨的博客
03-10 8454
Graphics类是GDI+技术的一个基本类。GDI+（Graphics Device Interface）是.NET框架的重要组成部分，提供对二维图形图像和文字排版处理的支持。System.Drawing.Drawing2D： 提供了高级的二维和矢量绘图功能（比如渐变、 图案填充、- 轨迹等）System.Drawing：提供了最基本的绘图功能（比如画直线、矩形、椭圆等）；System.Drawing.Printing： 提供与打印相关的服务。System.Drawing.Text： 提供排版功能。
C#---GDI
m0_56837227的博客
06-29 3095
简单介绍GDI+绘图类和主要函数
基于C#实现的简易绘图工具设计
热门推荐
毕业作品网站
04-20 1万+
全套资料下载地址：https://download.csdn.net/download/sheziqiong/85595877 全套资料下载地址：https://download.csdn.net/download/sheziqiong/85595877实验目的:通过制作窗体应用程序(C#画图软件),熟悉基本的窗体设计过程以及控件设计,事件处理等,熟悉使用C#的winform窗体进行绘图的基本步骤,对于面向对象编程有更加深刻的体会.设计一个具有基本功能的画图软件**·包括简单的新建文件,保存,重新绘图等功能
超全的C# GDI+画图板
03-07
通过研究这个源代码，你可以深入理解C# GDI+画图板的实现细节，并且可以将其作为模板，根据自己的需求进行扩展和定制。 总的来说，C# GDI+画图板是一个很好的学习平台，它涵盖了图形绘制、用户交互和文件操作等多个...
C#使用GDI+画图工具
06-02
这里实现了一些绘图工具的基本功能，例如画点、线、多边形、圆。包含了多种算法，例如Bresenham、DDA算法等。还可以进行多边形的扫描填充、多边形裁剪、直线裁剪、清空和退出。还包含了一个说明文件详细解释了使用...
C# gdi+ 画图写文字
03-16
摘要:C#源码,图形图像,GDI+,画图,贝塞尔曲线 C# gdi+ 画图源码，可以写文字，画圆弧，画直线，画椭圆，画贝塞尔曲线。如运行截图所示，图上的蓝色线条就是用GDI画出来的。 运行环境：ASP+Access
c# GDI+ 实现类似画图板的效果，有画矩形、直线、椭圆，保存，新建，擦除，颜色变换
03-07
以上就是使用C# GDI+实现类似画图板效果的基本步骤和技术要点。这个项目可以作为一个基础，进一步扩展功能，如添加更多的形状、添加图层管理、支持撤销/重做等。通过实践，你可以深入理解GDI+的强大和灵活性，为开发...
纯C#实现的mspaint增强版画图程序
08-12
标题中的“纯C#实现的mspaint增强版画图程序”指的是一个基于C#编程语言开发的图形编辑软件，它是对Windows系统自带的“画图”（mspaint）程序的一个功能增强版本。这个程序利用了.NET框架提供的WinForm技术以及GDI+...
C#绘图工具
jllll_kk的博客
05-16 6411
大一下学期学习了C#，由于课程设计需要，所以写了这个小程序，主要用到的由C#中的委托，VisualStuidio的WinForm编程。此程序实现了简单的画笔，油漆桶，文字，形状（矩形和椭圆）工具等功能以及对工具属性的设置。
基于C#的画图应用程序（窗体应用程序）C#组件、控件
weixin_56305254的博客
12-13 5073
使用VS2019，建立窗体应用程序，借助一系列控件实现画图功能。结合组件与控件的使用。
用C#实现工控上位机
09-25
结合Github高星开源项目SharpSCADA讲解工控上位机开发，重视基础，突出实战，为广大工控从业者、编程爱好者提供一种新颖的解决方案，可以快速搭建强大易用可扩展的工控上位机，并在此开源项目基础上开发工业大数据和MES系统，定制个性化的工业自动化行业解决方案。在学习过程中，可加深对C#语言和.NET平台的理解，进一步了解工业以太网协议，熟练对WPF技术的应用，透析组态软件的架构。
C# GDI+绘图高级编程（包含滚动条后重绘）
波波诸葛伟
10-20 5115
理解绘图规则 一般来说，Windows的一个优点（实际上是现代操作系统的优点）是它可以让开发人员不考虑特定设备的细节。例如：不需要理解硬盘设备驱动程序，只需在相关的.NET类中调用合适的方法，就可以编程读写磁盘上的文件。这个规则也适用于绘图。计算机在屏幕上绘图时，把指令发送给视频卡。问题是市面上有几百种不同的视频卡，大多数有不同的指令集合功能。如果把这个i考虑在内，在应用程序中为每个视频卡驱动程序编写在屏幕上绘图的特定代码，这样的应用程序就根本不可能编写出来。这就是为什么在Windows最早的版本中有Win
C#——GDI+基础
weixin_42031602的博客
12-31 2413
简单的GDI+基础
c# GDI 带角度的矩形鼠标改变缩放矩形大小
06-09
您可以通过以下步骤实现带角度的矩形鼠标改变缩放矩形大小： 1. 定义一个类来表示带角度的矩形，该类应包含矩形的位置、大小和角度等信息。 2. 在矩形的周围绘制一些调整大小的手柄，使用户可以使用鼠标拖拽来调整矩形的大小。 3. 当用户拖拽调整大小的手柄时，根据手柄的位置和移动距离来计算矩形的新位置和大小，并重新绘制矩形。 4. 当用户拖拽矩形本身时，根据鼠标的移动距离来计算矩形的新位置，并重新绘制矩形。 5. 当用户拖拽矩形的角度调整手柄时，根据鼠标的移动距离来计算矩形的新角度，并重新绘制矩形。 6. 为了实现缩放时的平移效果，可以在拖拽调整大小的手柄时，根据手柄的位置和移动距离来计算缩放中心点，并将矩形的位置相应地调整。 注意：实现带角度的矩形鼠标改变缩放矩形大小涉及到一些复杂的数学计算，需要仔细考虑并实现相应的算法。
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

yangzm996

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值