Update 20250204

WinSign/Sign.cs

@@ -0,0 +1,275 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Data;
+using System.Text;
+using System.Windows.Forms;
+using System.Drawing;
+using System.Drawing.Drawing2D;
+using System.Drawing.Imaging;
+using System.Reflection;
+
+namespace WinSign
+{
+    public partial class Sign : UserControl
+    {
+        private bool _shouldSign = false;
+        private BackgroundWorker _bgWorker = new BackgroundWorker();
+        string _signPointsX = "";
+        string _signPointsY = "";
+
+        public Sign()
+        {
+            InitializeComponent();
+
+            this.BorderStyle = BorderStyle.FixedSingle;
+            _bgWorker.RunWorkerCompleted += new RunWorkerCompletedEventHandler(_bgWorker_RunWorkerCompleted);
+            _bgWorker.DoWork += new DoWorkEventHandler(_bgWorker_DoWork);
+            this.DoubleBuffered = true;
+        }
+
+        #region " Properties "
+
+        /// <summary>
+        /// The format to save the signature file
+        /// </summary>
+        private ImageFormat _signatureFileFormat = ImageFormat.Bmp;
+        public ImageFormat FileFormat
+        {
+            get { return _signatureFileFormat; }
+            set { _signatureFileFormat = value; }
+        }
+
+        /// <summary>
+        /// The format to save the signature file
+        /// </summary>
+        private Bitmap _signatureBitmap = null;
+        public Bitmap SignatureBitmap
+        {
+            get { return _signatureBitmap; }
+        }
+
+        /// <summary>
+        /// Color of the signature Default BLUE
+        /// </summary>
+        private Color _penColor = Color.Blue;
+        public Color PenColor
+        {
+            get { return _penColor; }
+            set { _penColor = value; }
+        }
+
+        /// <summary>
+        /// Width of the Signature Default 4
+        /// </summary>
+        private int _penWidth = 4;
+        public int PenWidth
+        {
+            get { return _penWidth; }
+            set { _penWidth = value; }
+        }
+
+        /// <summary>
+        /// Required points for valid sign
+        /// </summary>
+        private int _requiredPoints = 20;
+        public int RequiredPoints
+        {
+            get { return _requiredPoints; }
+            set { _requiredPoints = value; }
+        }
+
+        /// <summary>
+        /// Background Image (Bitmap) for sign
+        /// </summary>
+        private Bitmap _backgroundImageBitmap = null;
+        public Bitmap BackgroundImageBitmap
+        {
+            get { return _backgroundImageBitmap; }
+            set { _backgroundImageBitmap = value; }
+        }
+
+        /// <summary>
+        /// Informs if the sign was present
+        /// </summary>
+        /// <returns></returns>
+        public bool IsValid
+        {
+            get
+            {
+                return (_signPointsX.Replace("|","").Trim().Length >= _requiredPoints);
+            }
+        }
+        
+        #endregion
+
+        void _bgWorker_DoWork(object sender, DoWorkEventArgs e)
+        {
+            e.Result = GetSignImage();
+        }
+
+        void _bgWorker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
+        {
+            this.BackgroundImage = (e.Result as Bitmap);
+            this.Refresh();
+        }
+
+        private void AddtoX(string x)
+        {
+            _signPointsX = _signPointsX + x;
+        }
+
+        private void AddtoY(string y)
+        {
+            _signPointsY = _signPointsY + y;
+        }
+
+        private void Sign_MouseDown(object sender, MouseEventArgs e)
+        {
+            _shouldSign = true;
+            tmrRefresh.Start();
+
+            AddtoX(e.X.ToString() + ",");
+            AddtoY(e.Y.ToString() + ",");
+        }
+
+        private void Sign_MouseLeave(object sender, EventArgs e)
+        {
+            _shouldSign = false;
+            tmrRefresh.Stop();
+
+            AddtoX("|");
+            AddtoY("|");
+        }
+
+        private void Sign_MouseMove(object sender, MouseEventArgs e)
+        {
+            if (_shouldSign)
+            {
+                AddtoX(e.X.ToString() + ',');
+                AddtoY(e.Y.ToString() + ',');
+            }
+        }
+
+        private void GenerateSign()
+        {
+            if (!_bgWorker.IsBusy)
+            {
+                _bgWorker.RunWorkerAsync();
+            }
+        }
+
+        public void ClearSignature()
+        {
+            _signPointsX = "";
+            _signPointsY = "";
+
+            if (null != this.BackgroundImage)
+            {
+                this.BackgroundImage = null;
+            }
+
+            _signatureBitmap = null;
+
+            if (_backgroundImageBitmap != null)
+            {
+                this.BackgroundImage = _backgroundImageBitmap; 
+            }
+
+            this.Refresh();
+        }
+
+        private void Sign_MouseUp(object sender, MouseEventArgs e)
+        {
+            _shouldSign = false;
+            tmrRefresh.Stop();
+            GenerateSign();
+
+            AddtoX("|");
+            AddtoY("|");
+        }
+
+        private void tmrRefresh_Tick(object sender, EventArgs e)
+        {
+           GenerateSign();       
+        }
+
+        [Obfuscation(Feature = "virtualization", Exclude = false)]
+        private Bitmap GetSignImage()
+        {
+            string[] arrX = _signPointsX.Split('|');
+            string[] arrY = _signPointsY.Split('|');
+            int CurrX = 0;
+            int CurrY = 0;
+
+            Bitmap bmp = null;
+
+            if (_backgroundImageBitmap != null)
+                bmp = (Bitmap)_backgroundImageBitmap.Clone();
+            else 
+                bmp = new Bitmap(this.Width, this.Height);
+
+            Graphics g = null;
+
+            try
+            {
+                g = Graphics.FromImage(bmp);
+                g.SmoothingMode = SmoothingMode.AntiAlias;
+
+                if (_backgroundImageBitmap == null)
+                {
+                    if (this.FileFormat != ImageFormat.Png || ((this.BackColor != Color.White)))
+                    {
+                        g.FillRectangle(new SolidBrush(this.BackColor), 0, 0, bmp.Width, bmp.Height);
+                    }
+                }
+
+                Pen pn = new Pen(new SolidBrush(this.PenColor),this.PenWidth);
+
+                for (int i = 0; i < arrX.Length; i++)
+                {
+                    if (arrX[i].Length > 0)
+                    {
+                        string[] innerPointsX = arrX[i].Split(',');
+                        string[] innerPointsY = arrY[i].Split(',');
+
+                        PointF[] tfArray = new PointF[innerPointsX.Length - 1];
+
+                        for (int j = 0; j < innerPointsX.Length - 1; j++)
+                        {
+                            if (innerPointsX[j].Length > 0)
+                            {
+                                CurrX = Convert.ToInt32(innerPointsX[j]);
+                                CurrY = Convert.ToInt32(innerPointsY[j]);
+
+                                PointF tf = new PointF(CurrX, CurrY);
+                                tfArray[j] = tf;
+
+                            }
+                        }
+
+                        GraphicsPath path = new GraphicsPath();
+                        path.AddLines(tfArray);
+                        g.DrawPath(pn, path);
+                    }
+                }
+
+            }
+            catch (Exception ex)
+            {
+                string err = ex.Message.ToString();
+                this.ClearSignature();
+            }
+            finally
+            {
+                if (null != g)
+                    g.Dispose();
+            }
+
+            _signatureBitmap = bmp;
+            return bmp;
+        }
+
+      
+    }
+}